diff --git a/Disease prediction/app.py b/Disease prediction/app.py
index 94810bdf..ad1d1c29 100644
--- a/Disease prediction/app.py	
+++ b/Disease prediction/app.py	
@@ -1,122 +1,71 @@
 from flask import Flask, render_template, request, jsonify
-from utils import load_keras_model, predict_image_keras
 import os
-import re
-from functools import wraps
-from werkzeug.utils import secure_filename
+import requests
+import json
 
 app = Flask(__name__)
 
-UPLOAD_FOLDER = r'disease/static/uploads'
-app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
-os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+# Configuration for Unified Pipeline
+# In production, this would be an env variable pointing to the main backend service
+PIPELINE_API_URL = "http://localhost:5000/api/v1/ingest/upload"
+PIPELINE_STATUS_URL = "http://localhost:5000/api/v1/ingest/status/"
 
-# Security configuration
-ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'bmp'}
-MAX_FILE_SIZE = 16 * 1024 * 1024  # 16MB max file size
-
-# Input validation helper functions
-def allowed_file(filename):
-    """Check if file extension is allowed"""
-    return '.' in filename and \
-           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
-
-def sanitize_filename(filename):
-    """Sanitize filename to prevent path traversal attacks"""
-    if not filename:
-        return ""
-    # Remove any path separators and dangerous characters
-    cleaned = re.sub(r'[<>:"/\\|?*]', '', filename)
-    return secure_filename(cleaned)
-
-def validate_file_size(file):
-    """Validate file size"""
-    if file.content_length and file.content_length > MAX_FILE_SIZE:
-        return False
-    return True
-
-# Load the Keras model
-try:
-    model = load_keras_model(r'disease/model.h5')
-except Exception as e:
-    app.logger.error(f"Failed to load model: {str(e)}")
-    model = None
-
-# Route for homepage
 @app.route('/')
 def index():
     return render_template('index.html')
 
-# Route for prediction
 @app.route('/predict', methods=['POST'])
 def predict():
+    """
+    Proxies the prediction request to the Unified Data Extraction Pipeline.
+    """
     try:
-        # Check if file was uploaded
         if 'file' not in request.files:
             return jsonify({'error': 'No file uploaded'}), 400
         
         file = request.files['file']
-        
-        # Check if file was selected
         if file.filename == '':
             return jsonify({'error': 'No file selected'}), 400
+
+        # Forward to Central Pipeline
+        files = {'file': (file.filename, file.stream, file.mimetype)}
+        data = {
+            'type': 'DISEASE',
+            'metadata': json.dumps({'source': 'web_legacy_app'})
+        }
         
-        # Validate file extension
-        if not allowed_file(file.filename):
-            return jsonify({'error': 'Invalid file type. Allowed: PNG, JPG, JPEG, GIF, BMP'}), 400
-        
-        # Validate file size
-        if not validate_file_size(file):
-            return jsonify({'error': f'File too large. Maximum size: {MAX_FILE_SIZE // (1024*1024)}MB'}), 400
-        
-        # Sanitize filename
-        filename = sanitize_filename(file.filename)
-        if not filename:
-            return jsonify({'error': 'Invalid filename'}), 400
-        
-        # Create unique filename to prevent overwrites
-        import uuid
-        unique_filename = f"{uuid.uuid4().hex}_{filename}"
-        filepath = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
-        
-        # Save file
-        file.save(filepath)
-        
-        # Check if model is loaded
-        if model is None:
-            return jsonify({'error': 'Model not available'}), 500
-        
-        # Make prediction
-        predicted_class, description = predict_image_keras(model, filepath)
+        # Note: In a real microservice mesh, we'd use mutual TLS or internal tokens.
+        # Here we assume an internal call.
+        response = requests.post(PIPELINE_API_URL, files=files, data=data)
         
-        # Clean up uploaded file (optional - remove if you want to keep files)
-        try:
-            os.remove(filepath)
-        except:
-            pass  # Ignore cleanup errors
+        if response.status_code != 202:
+            return jsonify({'error': f"Pipeline Error: {response.text}"}), response.status_code
+            
+        result_data = response.json()
+        tracking_id = result_data.get('tracking_id')
         
-        return render_template('result.html',
-                               prediction=predicted_class,
-                               description=description,
-                               image_path=filepath)
-                               
-    except Exception as e:
-        app.logger.error(f"Prediction error: {str(e)}")
-        return jsonify({'error': 'Prediction failed'}), 500
+        # Poll for result (Simple implementation for legacy compatibility)
+        # In a real app, we'd use WebSockets or redirect the user to a status page
+        import time
+        for _ in range(10): # Try for 10 seconds
+            time.sleep(1)
+            status_resp = requests.get(PIPELINE_STATUS_URL + tracking_id)
+            if status_resp.status_code == 200:
+                status_data = status_resp.json().get('data', {})
+                if status_data.get('status') == 'COMPLETED':
+                    result = status_data.get('result', {})
+                    return render_template('result.html',
+                                           prediction=result.get('prediction'),
+                                           description=result.get('recommendation'),
+                                           image_path=status_data.get('filename')) # Path might need adjustment for serving
+                elif status_data.get('status') == 'FAILED':
+                   return jsonify({'error': 'Processing Failed'}), 500
 
-# Global error handlers
-@app.errorhandler(400)
-def bad_request(error):
-    return jsonify({'error': 'Bad request'}), 400
+        return jsonify({'message': 'Processing started. Check status later.', 'tracking_id': tracking_id}), 202
 
-@app.errorhandler(413)
-def too_large(error):
-    return jsonify({'error': 'File too large'}), 413
-
-@app.errorhandler(500)
-def internal_error(error):
-    app.logger.error(f"Internal error: {str(error)}")
-    return jsonify({'error': 'Internal server error'}), 500
+    except Exception as e:
+        app.logger.error(f"Proxy error: {str(e)}")
+        return jsonify({'error': 'Internal Proxy Error'}), 500
 
 if __name__ == '__main__':
-    app.run(debug=True)
\ No newline at end of file
+    app.run(debug=True, port=5001) # Run on different port to main app
diff --git a/Soil Classification Model/main.py b/Soil Classification Model/main.py
new file mode 100644
index 00000000..ff40ba56
--- /dev/null
+++ b/Soil Classification Model/main.py	
@@ -0,0 +1,44 @@
+import os
+import json
+import random
+
+class SoilClassifier:
+    """
+    Wrapper for the Soil Classification Model.
+    In a real scenario, this would load the .pkl or .h5 model.
+    """
+    
+    def __init__(self, model_path=None):
+        self.model_path = model_path
+        # Load model here
+        pass
+
+    def predict(self, input_data):
+        """
+        Classifies soil based on input features or image.
+        """
+        # Mocking the classification logic from the notebook
+        soil_types = ['Black Soil', 'Red Soil', 'Clay Soil', 'Alluvial Soil']
+        crops = {
+            'Black Soil': ['Cotton', 'Wheat', 'Sugarcane'],
+            'Red Soil': ['Groundnut', 'Potato', 'Rice'],
+            'Clay Soil': ['Rice', 'Lettuce', 'Broccoli'],
+            'Alluvial Soil': ['Rice', 'Wheat', 'Sugarcane']
+        }
+        
+        predicted_type = random.choice(soil_types)
+        
+        return {
+            'soil_type': predicted_type,
+            'recommended_crops': crops[predicted_type],
+            'confidence': round(random.uniform(0.85, 0.99), 2),
+            'attributes': {
+                'pH': round(random.uniform(5.5, 8.5), 1),
+                'moisture': f"{random.randint(20, 80)}%"
+            }
+        }
+
+if __name__ == "__main__":
+    # Test run
+    classifier = SoilClassifier()
+    print(classifier.predict({}))
diff --git a/app.py b/app.py
index 70f0b458..11eaa6a7 100644
--- a/app.py
+++ b/app.py
@@ -12,6 +12,8 @@
 from backend.utils.validation import validate_input, sanitize_input
 from backend.extensions import socketio, db, migrate, mail, limiter, babel, get_locale
 from backend.api.v1.files import files_bp
+from backend.api.ingestion import ingestion_bp
+from backend.middleware.audit import AuditMiddleware
 from crop_recommendation.routes import crop_bp
 # from disease_prediction.routes import disease_bp
 from spatial_analytics.routes import spatial_bp
@@ -27,6 +29,7 @@
 from auth_utils import token_required, roles_required
 import backend.sockets.forum_events # Register forum socket events
 import backend.sockets.knowledge_events # Register knowledge exchange events
+import backend.sockets.alert_socket # Register centralized alert socket events
 from backend.utils.i18n import t
 from server.Routes.rotation_routes import rotation_bp
 
@@ -60,6 +63,9 @@
 # Initialize Celery with app context
 celery = make_celery(app)
 
+# Initialize Audit Middleware
+audit_mw = AuditMiddleware(app)
+
 # Import models after db initialization
 from backend.models import User
 
@@ -70,6 +76,7 @@
 app.register_blueprint(health_bp)
 app.register_blueprint(files_bp)
 app.register_blueprint(spatial_bp)
+app.register_blueprint(ingestion_bp, url_prefix='/api/v1')
 
 # Register API v1 (including loan, weather, schemes, etc.)
 register_api(app)
diff --git a/audit_dashboard.html b/audit_dashboard.html
new file mode 100644
index 00000000..2bdf25f7
--- /dev/null
+++ b/audit_dashboard.html
@@ -0,0 +1,299 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Security & Audit Dashboard | AgriTech Admin</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <link rel="stylesheet" href="css/style.css">
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <style>
+        :root {
+            --bg-deep: #020617;
+            --surface-panel: #0f172a;
+            --danger-red: #ef4444;
+            --warning-amber: #f59e0b;
+            --success-cyan: #06b6d4;
+            --border-muted: #1e293b;
+        }
+
+        body {
+            background-color: var(--bg-deep);
+            color: #e2e8f0;
+            font-family: 'Inter', sans-serif;
+            margin: 0;
+            padding: 0;
+        }
+
+        .admin-sidebar {
+            width: 260px;
+            height: 100vh;
+            background: var(--surface-panel);
+            position: fixed;
+            border-right: 1px solid var(--border-muted);
+            padding: 20px;
+        }
+
+        .main-content {
+            margin-left: 300px;
+            padding: 40px;
+        }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(4, 1fr);
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+
+        .stat-card {
+            background: var(--surface-panel);
+            padding: 24px;
+            border-radius: 16px;
+            border: 1px solid var(--border-muted);
+        }
+
+        .stat-card h3 {
+            margin: 0;
+            font-size: 0.85rem;
+            color: #94a3b8;
+            text-transform: uppercase;
+        }
+
+        .stat-card .value {
+            font-size: 2rem;
+            font-weight: 800;
+            margin: 10px 0;
+        }
+
+        .stat-card.threat {
+            border-left: 4px solid var(--danger-red);
+        }
+
+        .stat-card.active {
+            border-left: 4px solid var(--success-cyan);
+        }
+
+        .dashboard-row {
+            display: grid;
+            grid-template-columns: 2fr 1fr;
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+
+        .table-container {
+            background: var(--surface-panel);
+            border-radius: 16px;
+            border: 1px solid var(--border-muted);
+            overflow: hidden;
+        }
+
+        table {
+            width: 100%;
+            border-collapse: collapse;
+        }
+
+        th {
+            background: rgba(255, 255, 255, 0.02);
+            text-align: left;
+            padding: 16px;
+            font-size: 0.85rem;
+            border-bottom: 1px solid var(--border-muted);
+        }
+
+        td {
+            padding: 16px;
+            font-size: 0.9rem;
+            border-bottom: 1px solid var(--border-muted);
+        }
+
+        .risk-badge {
+            padding: 4px 10px;
+            border-radius: 6px;
+            font-size: 0.75rem;
+            font-weight: bold;
+        }
+
+        .risk-CRITICAL {
+            background: rgba(239, 68, 68, 0.1);
+            color: #ef4444;
+        }
+
+        .risk-HIGH {
+            background: rgba(245, 158, 11, 0.1);
+            color: #f59e0b;
+        }
+
+        .risk-MEDIUM {
+            background: rgba(59, 130, 246, 0.1);
+            color: #3b82f6;
+        }
+
+        .threat-warning {
+            animation: pulse 2s infinite;
+            color: var(--danger-red);
+        }
+
+        @keyframes pulse {
+            0% {
+                opacity: 1;
+            }
+
+            50% {
+                opacity: 0.5;
+            }
+
+            100% {
+                opacity: 1;
+            }
+        }
+
+        .chart-container {
+            background: var(--surface-panel);
+            padding: 20px;
+            border-radius: 16px;
+            border: 1px solid var(--border-muted);
+        }
+    </style>
+</head>
+
+<body>
+    <div class="admin-sidebar">
+        <h2 style="color: var(--success-cyan);"><i class="fas fa-shield-virus"></i> AgriAudit</h2>
+        <nav style="margin-top: 40px;">
+            <div style="padding: 10px 0; color: #64748b; font-size: 0.8rem;">OPERATIONS</div>
+            <a href="#" style="display: block; color: white; padding: 12px 0; text-decoration: none;"><i
+                    class="fas fa-tachometer-alt"></i> Dashboard</a>
+            <a href="#" style="display: block; color: #94a3b8; padding: 12px 0; text-decoration: none;"><i
+                    class="fas fa-list"></i> Full Logs</a>
+            <a href="#" style="display: block; color: #94a3b8; padding: 12px 0; text-decoration: none;"><i
+                    class="fas fa-user-lock"></i> Active Sessions</a>
+        </nav>
+    </div>
+
+    <div class="main-content">
+        <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 30px;">
+            <h1>Security Monitoring</h1>
+            <button class="btn" style="background: var(--success-cyan); color: black;" onclick="refreshDashboard()">
+                <i class="fas fa-sync"></i> Refresh Data
+            </button>
+        </div>
+
+        <div class="stats-grid">
+            <div class="stat-card">
+                <h3>Total Interactions (24h)</h3>
+                <div class="value" id="stat-total">--</div>
+            </div>
+            <div class="stat-card threat">
+                <h3>Threats Blocked</h3>
+                <div class="value" id="stat-threats" style="color: var(--danger-red);">--</div>
+            </div>
+            <div class="stat-card active">
+                <h3>Active Sessions</h3>
+                <div class="value" id="stat-sessions" style="color: var(--success-cyan);">--</div>
+            </div>
+            <div class="stat-card">
+                <h3>System Gravity</h3>
+                <div class="value" id="stat-gravity">ALIGNED</div>
+            </div>
+        </div>
+
+        <div class="dashboard-row">
+            <div class="table-container">
+                <div
+                    style="padding: 20px; border-bottom: 1px solid var(--border-muted); display: flex; justify-content: space-between;">
+                    <h2 style="margin:0; font-size: 1.2rem;">Recent Audit Stream</h2>
+                    <span style="color: #64748b; font-size: 0.8rem;">LIVE AUTO-REFRESH</span>
+                </div>
+                <table id="logs-table">
+                    <thead>
+                        <tr>
+                            <th>TIMESTAMP</th>
+                            <th>USER</th>
+                            <th>ACTION</th>
+                            <th>RISK</th>
+                            <th>IP</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <!-- Dynamic Rows -->
+                    </tbody>
+                </table>
+            </div>
+
+            <div class="chart-container">
+                <h3>Risk Distribution</h3>
+                <canvas id="riskChart"></canvas>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        async function fetchStats() {
+            try {
+                const res = await fetch('/api/v1/audit/stats', {
+                    headers: { 'Authorization': `Bearer ${localStorage.getItem('token')}` }
+                });
+                const data = await res.json();
+                if (data.status === 'success') {
+                    document.getElementById('stat-total').innerText = data.stats.total_actions_24h;
+                    document.getElementById('stat-threats').innerText = data.stats.threats_detected_24h;
+                    document.getElementById('stat-sessions').innerText = data.stats.active_users;
+                    updateChart(data.stats.risk_distribution);
+                }
+            } catch (e) { console.error(e); }
+        }
+
+        async function fetchLogs() {
+            try {
+                const res = await fetch('/api/v1/audit/logs?limit=15', {
+                    headers: { 'Authorization': `Bearer ${localStorage.getItem('token')}` }
+                });
+                const data = await res.json();
+                const tbody = document.querySelector('#logs-table tbody');
+                tbody.innerHTML = data.logs.map(log => `
+                    <tr>
+                        <td style="color: #64748b;">${new Date(log.timestamp).toLocaleTimeString()}</td>
+                        <td>${log.user_id ? `User #${log.user_id}` : 'ANONYMOUS'}</td>
+                        <td style="font-weight: 500;">
+                            ${log.threat_flag ? `<i class="fas fa-exclamation-triangle threat-warning"></i> ` : ''}
+                            ${log.action}
+                        </td>
+                        <td><span class="risk-badge risk-${log.risk_level}">${log.risk_level}</span></td>
+                        <td style="font-family: monospace; font-size: 0.8rem;">${log.ip_address}</td>
+                    </tr>
+                `).join('');
+            } catch (e) { console.error(e); }
+        }
+
+        let chart;
+        function updateChart(data) {
+            const ctx = document.getElementById('riskChart').getContext('2d');
+            if (chart) chart.destroy();
+            chart = new Chart(ctx, {
+                type: 'doughnut',
+                data: {
+                    labels: Object.keys(data),
+                    datasets: [{
+                        data: Object.values(data),
+                        backgroundColor: ['#3b82f6', '#f59e0b', '#ef4444', '#06b6d4'],
+                        borderWidth: 0
+                    }]
+                },
+                options: { plugins: { legend: { position: 'bottom', labels: { color: 'white' } } } }
+            });
+        }
+
+        function refreshDashboard() {
+            fetchStats();
+            fetchLogs();
+        }
+
+        // Initial Load
+        refreshDashboard();
+        setInterval(refreshDashboard, 30000);
+    </script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/backend/api/ingestion.py b/backend/api/ingestion.py
new file mode 100644
index 00000000..f6fa7e30
--- /dev/null
+++ b/backend/api/ingestion.py
@@ -0,0 +1,59 @@
+from flask import Blueprint, request, jsonify
+from backend.services.pipeline_service import MediaPipelineService
+from auth_utils import token_required
+import json
+
+ingestion_bp = Blueprint('ingestion', __name__)
+
+@ingestion_bp.route('/ingest/upload', methods=['POST'])
+@token_required
+def upload_media():
+    """
+    Standardized endpoint for all media and data file uploads.
+    Supports DISEASE, SOIL, CROP, EQUIPMENT types.
+    """
+    if 'file' not in request.files:
+        return jsonify({'status': 'error', 'message': 'No file part'}), 400
+        
+    file = request.files['file']
+    payload_type = request.form.get('type')
+    metadata_raw = request.form.get('metadata', '{}')
+    
+    if not payload_type:
+        return jsonify({'status': 'error', 'message': 'Payload type is required'}), 400
+        
+    try:
+        metadata = json.loads(metadata_raw)
+    except Exception:
+        return jsonify({'status': 'error', 'message': 'Invalid metadata JSON'}), 400
+        
+    user_id = request.user.get('id') or request.user.get('user_id')
+    
+    payload, error = MediaPipelineService.ingest_payload(
+        file, 
+        payload_type.upper(), 
+        user_id=user_id, 
+        metadata=metadata
+    )
+    
+    if error:
+        return jsonify({'status': 'error', 'message': error}), 400
+        
+    return jsonify({
+        'status': 'success',
+        'message': 'Payload ingested and processing started',
+        'tracking_id': payload.tracking_id
+    }), 202
+
+@ingestion_bp.route('/ingest/status/<tracking_id>', methods=['GET'])
+@token_required
+def get_status(tracking_id):
+    """Check the status of a specific processing tracking ID."""
+    payload = MediaPipelineService.get_payload_status(tracking_id)
+    if not payload:
+        return jsonify({'status': 'error', 'message': 'Invalid tracking ID'}), 404
+        
+    return jsonify({
+        'status': 'success',
+        'data': payload.to_dict()
+    }), 200
diff --git a/backend/api/v1/__init__.py b/backend/api/v1/__init__.py
index e0d152c7..2d92a5a3 100644
--- a/backend/api/v1/__init__.py
+++ b/backend/api/v1/__init__.py
@@ -34,6 +34,9 @@
 from .loan_repayment import loan_repayment_bp
 from .warehouse import warehouse_bp
 from .climate_control import climate_bp
+from .labor_management import labor_bp
+from .logistics_portal import logistics_portal_bp
+from .audit import audit_bp
 
 # Create v1 API blueprint
 api_v1 = Blueprint('api_v1', __name__, url_prefix='/api/v1')
@@ -74,4 +77,6 @@
 api_v1.register_blueprint(loan_repayment_bp, url_prefix='/loans')
 api_v1.register_blueprint(warehouse_bp, url_prefix='/warehouse')
 api_v1.register_blueprint(climate_bp, url_prefix='/climate')
- 
+api_v1.register_blueprint(labor_bp, url_prefix='/labor')
+api_v1.register_blueprint(logistics_portal_bp, url_prefix='/logistics-v2')
+api_v1.register_blueprint(audit_bp)
diff --git a/backend/api/v1/assets.py b/backend/api/v1/assets.py
index 67bb45e6..3cffd597 100644
--- a/backend/api/v1/assets.py
+++ b/backend/api/v1/assets.py
@@ -13,6 +13,7 @@
     AssetCreateSchema, AssetUpdateSchema, TelemetrySchema,
     MaintenanceLogSchema, AssetQuerySchema
 )
+from services.audit_service import AuditService
 
 logger = logging.getLogger(__name__)
 
@@ -51,6 +52,14 @@ def register_asset():
         # Create asset
         asset = AssetService.create_asset(current_user_id, validated_data)
         
+        AuditService.log_action(
+            action="ASSET_REGISTERED",
+            user_id=current_user_id,
+            resource_type="FARM_ASSET",
+            resource_id=asset.asset_id,
+            meta_data={"name": asset.asset_name, "type": asset.asset_type}
+        )
+        
         return jsonify({
             'success': True,
             'message': 'Asset registered successfully',
@@ -149,6 +158,14 @@ def predict_failure(asset_id):
         # Run AI prediction
         prediction = AssetService.predict_failure_ai(asset_id)
         
+        AuditService.log_action(
+            action="ASSET_FAILURE_PREDICTION",
+            user_id=current_user_id,
+            resource_type="FARM_ASSET",
+            resource_id=asset_id,
+            meta_data={"result": prediction.get('status')}
+        )
+        
         return jsonify({
             'success': True,
             'message': 'Failure prediction completed',
@@ -450,6 +467,14 @@ def delete_asset(asset_id):
         asset.status = 'RETIRED'
         db.session.commit()
         
+        AuditService.log_action(
+            action="ASSET_RETIRED",
+            user_id=current_user_id,
+            resource_type="FARM_ASSET",
+            resource_id=asset_id,
+            risk_level="MEDIUM"
+        )
+        
         return jsonify({
             'success': True,
             'message': 'Asset retired successfully'
diff --git a/backend/api/v1/audit.py b/backend/api/v1/audit.py
new file mode 100644
index 00000000..64e368b0
--- /dev/null
+++ b/backend/api/v1/audit.py
@@ -0,0 +1,71 @@
+from flask import Blueprint, jsonify, request
+from backend.services.audit_service import AuditService
+from auth_utils import token_required, roles_required
+
+audit_bp = Blueprint('audit_bp', __name__, url_prefix='/audit')
+
+@audit_bp.route('/logs', methods=['GET'])
+@token_required
+@roles_required('admin')
+def get_audit_logs():
+    """Retrieves filtered audit logs (Admin only)."""
+    filters = {
+        'user_id': request.args.get('user_id', type=int),
+        'action': request.args.get('action'),
+        'risk_level': request.args.get('risk_level'),
+        'threat_only': request.args.get('threat_only') == 'true',
+        'start_date': request.args.get('start_date')
+    }
+    
+    limit = request.args.get('limit', 50, type=int)
+    offset = request.args.get('offset', 0, type=int)
+    
+    logs = AuditService.get_logs(filters, limit, offset)
+    return jsonify({
+        'status': 'success',
+        'count': len(logs),
+        'logs': [log.to_dict() for log in logs]
+    })
+
+@audit_bp.route('/sessions', methods=['GET'])
+@token_required
+@roles_required('admin')
+def get_active_sessions():
+    """Retrieves active user sessions."""
+    from backend.models import UserSession
+    sessions = UserSession.query.filter_by(is_active=True).order_by(UserSession.last_activity.desc()).all()
+    return jsonify({
+        'status': 'success',
+        'count': len(sessions),
+        'sessions': [s.to_dict() for s in sessions]
+    })
+
+@audit_bp.route('/stats', methods=['GET'])
+@token_required
+@roles_required('admin')
+def get_audit_stats():
+    """Returns high-level security and activity statistics."""
+    from backend.models import AuditLog, UserSession
+    from backend.extensions import db
+    from datetime import datetime, timedelta
+    
+    last_24h = datetime.utcnow() - timedelta(hours=24)
+    
+    total_actions = AuditLog.query.filter(AuditLog.timestamp >= last_24h).count()
+    threats_detected = AuditLog.query.filter(AuditLog.timestamp >= last_24h, AuditLog.threat_flag == True).count()
+    active_users = db.session.query(db.func.count(db.func.distinct(UserSession.user_id))).filter(UserSession.is_active == True).scalar()
+    
+    # Categorical breakdown
+    categories = db.session.query(
+        AuditLog.risk_level, db.func.count(AuditLog.id)
+    ).filter(AuditLog.timestamp >= last_24h).group_by(AuditLog.risk_level).all()
+    
+    return jsonify({
+        'status': 'success',
+        'stats': {
+            'total_actions_24h': total_actions,
+            'threats_detected_24h': threats_detected,
+            'active_users': active_users,
+            'risk_distribution': {level: count for level, count in categories}
+        }
+    })
diff --git a/backend/api/v1/auth.py b/backend/api/v1/auth.py
index 45ac5f80..3f18bf0c 100644
--- a/backend/api/v1/auth.py
+++ b/backend/api/v1/auth.py
@@ -1,5 +1,6 @@
 from flask import Blueprint, request, jsonify
 from backend.services.auth_service import AuthService
+from backend.services.audit_service import AuditService
 from backend.models import User
 from backend.extensions import db, limiter
 
@@ -28,6 +29,12 @@ def register():
     
     AuthService.send_verification_email(user)
     
+    AuditService.log_action(
+        action="USER_REGISTERED",
+        user_id=user.id,
+        meta_data={"username": username, "email": email}
+    )
+    
     return jsonify({
         'status': 'success',
         'message': 'User registered. Please check your email to verify your account.'
@@ -38,7 +45,9 @@ def verify_email(token):
     """Verify email endpoint."""
     success, message = AuthService.verify_email(token)
     if success:
+        AuditService.log_action(action="EMAIL_VERIFIED", meta_data={"token": token})
         return jsonify({'status': 'success', 'message': message}), 200
+    AuditService.log_action(action="EMAIL_VERIFICATION_FAILED", risk_level='MEDIUM', meta_data={"error": message})
     return jsonify({'status': 'error', 'message': message}), 400
 
 @auth_bp.route('/forgot-password', methods=['POST'])
@@ -54,6 +63,9 @@ def forgot_password():
     user = User.query.filter_by(email=email).first()
     if user:
         AuthService.send_password_reset_email(user)
+        AuditService.log_action(action="PASSWORD_RESET_REQUESTED", user_id=user.id)
+    else:
+        AuditService.log_action(action="UNKNOWN_PASSWORD_RESET_ATTEMPT", risk_level='MEDIUM', meta_data={"email": email})
     
     # Always return same message to prevent email enumeration
     return jsonify({
@@ -73,5 +85,7 @@ def reset_password(token):
         
     success, message = AuthService.reset_password(token, new_password)
     if success:
+        AuditService.log_action(action="PASSWORD_RESET_SUCCESSFUL")
         return jsonify({'status': 'success', 'message': message}), 200
+    AuditService.log_action(action="PASSWORD_RESET_FAILED", risk_level='MEDIUM', meta_data={"error": message})
     return jsonify({'status': 'error', 'message': message}), 400
diff --git a/backend/api/v1/forum.py b/backend/api/v1/forum.py
index a798babc..de60c47d 100644
--- a/backend/api/v1/forum.py
+++ b/backend/api/v1/forum.py
@@ -4,6 +4,8 @@
 from backend.models import ForumCategory
 from auth_utils import token_required
 from backend.utils.logger import logger
+from backend.middleware.audit import audit_request
+from backend.services.audit_service import AuditService
 
 forum_bp = Blueprint('forum', __name__)
 
@@ -23,6 +25,7 @@ def get_categories():
 
 @forum_bp.route('/forum/categories', methods=['POST'])
 @token_required
+@audit_request("ADMIN_CREATE_FORUM_CATEGORY")
 def create_category():
     """Create a new forum category (Admin only)"""
     try:
@@ -102,6 +105,7 @@ def get_thread(thread_id):
 
 @forum_bp.route('/forum/threads', methods=['POST'])
 @token_required
+@audit_request("CREATE_FORUM_THREAD")
 def create_thread():
     """Create a new thread"""
     try:
@@ -164,6 +168,14 @@ def create_comment(thread_id):
         if error:
             return jsonify({'status': 'error', 'message': error}), 500
         
+        AuditService.log_action(
+            action="POST_FORUM_COMMENT",
+            user_id=user['id'],
+            resource_type="COMMENT",
+            resource_id=str(comment.id),
+            meta_data={"thread_id": thread_id}
+        )
+        
         return jsonify({
             'status': 'success',
             'data': comment.to_dict(),
@@ -276,6 +288,7 @@ def ai_search():
 
 @forum_bp.route('/forum/flag', methods=['POST'])
 @token_required
+@audit_request("FLAG_FORUM_CONTENT")
 def flag_content():
     """Flag inappropriate content"""
     try:
diff --git a/backend/api/v1/loan.py b/backend/api/v1/loan.py
index a9929340..fb0489df 100644
--- a/backend/api/v1/loan.py
+++ b/backend/api/v1/loan.py
@@ -1,6 +1,7 @@
 from flask import Blueprint, request, jsonify, current_app
 import google.generativeai as genai
 from backend.utils.validation import sanitize_input, validate_input
+from backend.services.audit_service import AuditService
 
 from auth_utils import token_required, roles_required
 
@@ -53,6 +54,12 @@ def process_loan():
             }), 500
 
         reply = response.candidates[0].content.parts[0].text
+        
+        AuditService.log_action(
+            action="LOAN_ELIGIBILITY_CHECK",
+            meta_data={"loan_type": json_data.get('loan_type')}
+        )
+        
         return jsonify({
             "status": "success",
             "message": "Loan processed successfully",
diff --git a/backend/api/v1/market.py b/backend/api/v1/market.py
index 613c752c..d9b4dd68 100644
--- a/backend/api/v1/market.py
+++ b/backend/api/v1/market.py
@@ -2,6 +2,7 @@
 from backend.services.market_service import MarketIntelligenceService
 from backend.models import PriceWatchlist
 from backend.extensions import db
+from backend.services.audit_service import AuditService
 
 market_bp = Blueprint('market', __name__)
 
@@ -47,6 +48,14 @@ def add_to_watchlist():
     db.session.add(watchlist_item)
     db.session.commit()
     
+    AuditService.log_action(
+        action="MARKET_WATCHLIST_ADD",
+        user_id=user_id,
+        resource_type="MARKET_WATCHLIST",
+        resource_id=str(watchlist_item.id),
+        meta_data={"crop": crop, "target": target_price}
+    )
+    
     return jsonify({
         "status": "success",
         "message": f"Added {crop} to your watchlist."
@@ -56,6 +65,13 @@ def add_to_watchlist():
 def force_refresh_prices():
     """Manual trigger for price updates (Admin/Internal use)"""
     updated = MarketIntelligenceService.fetch_live_prices()
+    
+    AuditService.log_action(
+        action="MARKET_PRICE_REFRESH_MANUAL",
+        risk_level="MEDIUM",
+        meta_data={"updated_count": len(updated)}
+    )
+    
     return jsonify({
         "status": "success",
         "updated_count": len(updated)
diff --git a/backend/middleware/audit.py b/backend/middleware/audit.py
new file mode 100644
index 00000000..8b72ee8b
--- /dev/null
+++ b/backend/middleware/audit.py
@@ -0,0 +1,89 @@
+import time
+import functools
+from flask import request, g, has_request_context
+from backend.services.audit_service import AuditService
+
+def audit_request(action_name=None):
+    """
+    Decorator for explicitly auditing specific route actions.
+    Example: @audit_request("VIEW_SENSITIVE_DATA")
+    """
+    def decorator(f):
+        @functools.wraps(f)
+        def decorated_function(*args, **kwargs):
+            action = action_name or f"API_CALL_{request.endpoint}"
+            
+            # Record start time
+            start_time = time.time()
+            
+            # Execute the function
+            response = f(*args, **kwargs)
+            
+            # Calculate duration
+            duration = time.time() - start_time
+            
+            # Async log or direct log depends on performance needs
+            # For this "hard" issue, we'll do direct logging but capture status codes
+            status_code = 200
+            if hasattr(response, 'status_code'):
+                status_code = response.status_code
+            elif isinstance(response, tuple) and len(response) > 1:
+                status_code = response[1]
+                
+            AuditService.log_action(
+                action=action,
+                meta_data={
+                    "duration_ms": int(duration * 1000),
+                    "status": status_code,
+                    "endpoint": request.endpoint
+                }
+            )
+            return response
+        return decorated_function
+    return decorator
+
+class AuditMiddleware:
+    """
+    Global middleware to automatically audit high-risk requests.
+    """
+    def __init__(self, app=None):
+        if app is not None:
+            self.init_app(app)
+
+    def init_app(self, app):
+        app.before_request(self.before_request)
+        app.after_request(self.after_request)
+
+    def before_request(self):
+        # Store start time in flask.g for duration calculation
+        g.audit_start_time = time.time()
+
+    def after_request(self, response):
+        """
+        Post-request hook to log non-GET requests or specific endpoints.
+        """
+        if not has_request_context():
+            return response
+            
+        # We generally audit state-changing requests (POST, PUT, DELETE)
+        # and ignore GET requests unless they are to sensitive paths
+        is_state_change = request.method in ['POST', 'PUT', 'DELETE', 'PATCH']
+        is_sensitive = any(path in request.path for path in ['/admin', '/settings', '/auth'])
+        
+        if is_state_change or is_sensitive:
+            duration = time.time() - getattr(g, 'audit_start_time', time.time())
+            
+            # Avoid auditing the audit logs themselves to prevent infinite loops
+            if 'audit' in request.path:
+                return response
+                
+            AuditService.log_action(
+                action=f"{request.method}_{request.endpoint or 'unknown'}",
+                risk_level='MEDIUM' if is_state_change else 'LOW',
+                meta_data={
+                    "duration_ms": int(duration * 1000),
+                    "status_code": response.status_code
+                }
+            )
+            
+        return response
diff --git a/backend/models/__init__.py b/backend/models/__init__.py
index fc909c93..c23d1ca9 100644
--- a/backend/models/__init__.py
+++ b/backend/models/__init__.py
@@ -12,6 +12,9 @@
 from .knowledge import Question, Answer, KnowledgeVote, Badge, UserBadge, UserExpertise
 from .equipment import Equipment, RentalBooking, AvailabilityCalendar, PaymentEscrow
 from .farm import Farm, FarmMember, FarmAsset, FarmRole
+from .alert import Alert, AlertPreference
+from .audit_log import AuditLog, UserSession
+from .media_payload import MediaPayload
 from .weather import WeatherData, CropAdvisory, AdvisorySubscription
 from .sustainability import CarbonPractice, CreditLedger, AuditRequest
 from .vendor_profile import VendorProfile # Updated from procurement to vendor_profile
@@ -45,5 +48,10 @@
     'SoilTest', 'FertilizerRecommendation', 'ApplicationLog',
     'RepaymentSchedule', 'PaymentHistory', 'DefaultRiskScore', 'CollectionNote',
     'WarehouseLocation', 'StockItem', 'StockMovement', 'ReconciliationLog',
-    'ClimateZone', 'SensorNode', 'TelemetryLog', 'AutomationTrigger'
+    'ClimateZone', 'SensorNode', 'TelemetryLog', 'AutomationTrigger',
+    'WorkerProfile', 'WorkShift', 'HarvestLog', 'PayrollEntry',
+    'DriverProfile', 'DeliveryVehicle', 'TransportRoute', 'FuelLog',
+    'Alert', 'AlertPreference',
+    'AuditLog', 'UserSession',
+    'MediaPayload'
 ]
diff --git a/backend/models/alert.py b/backend/models/alert.py
new file mode 100644
index 00000000..9c9c614e
--- /dev/null
+++ b/backend/models/alert.py
@@ -0,0 +1,120 @@
+from datetime import datetime
+from backend.extensions import db
+
+class Alert(db.Model):
+    __tablename__ = 'alerts'
+
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)  # Null for broadcast
+    title = db.Column(db.String(255), nullable=False)
+    message = db.Column(db.Text, nullable=False)
+    
+    # Priority: LOW, MEDIUM, HIGH, CRITICAL
+    priority = db.Column(db.String(20), default='MEDIUM', nullable=False)
+    
+    # Category: WEATHER, MARKET, FORUM, SYSTEM, SECURITY, LOAN
+    category = db.Column(db.String(50), nullable=False)
+    
+    # Grouping key for similar alerts
+    group_key = db.Column(db.String(100), nullable=True)
+    
+    # Delivery Channels Status
+    websocket_delivered = db.Column(db.Boolean, default=False)
+    email_delivered = db.Column(db.Boolean, default=False)
+    sms_delivered = db.Column(db.Boolean, default=False)
+    push_delivered = db.Column(db.Boolean, default=False)
+    
+    # Expiry for cleanup
+    expires_at = db.Column(db.DateTime, nullable=True)
+    
+    read_at = db.Column(db.DateTime, nullable=True)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    # Metadata for deep-linking
+    action_url = db.Column(db.String(512), nullable=True)
+    metadata_json = db.Column(db.Text, nullable=True)  # JSON string for extra data
+
+    @property
+    def gravity_score(self) -> int:
+        """Calculates a numerical score for alert importance."""
+        base_scores = {'CRITICAL': 100, 'HIGH': 75, 'MEDIUM': 50, 'LOW': 25}
+        score = base_scores.get(self.priority, 50)
+        
+        # Boost score if category is high-risk
+        if self.category in ['SECURITY', 'MARKET']:
+            score += 20
+        
+        return score
+
+    def validate(self):
+        """Validates alert data before persistence."""
+        if not self.title or len(self.title) < 5:
+            raise ValueError("Alert title must be at least 5 characters long.")
+        if not self.category:
+            raise ValueError("Alert category is required.")
+        if self.priority not in ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']:
+            raise ValueError("Invalid priority level.")
+        return True
+
+    def to_dict(self):
+        """Serializes alert data for API and WebSocket delivery."""
+        res = {
+            'id': self.id,
+            'user_id': self.user_id,
+            'title': self.title,
+            'message': self.message,
+            'priority': self.priority,
+            'category': self.category,
+            'gravity': self.gravity_score,
+            'group_key': self.group_key,
+            'delivery_report': {
+                'websocket': self.websocket_delivered,
+                'email': self.email_delivered,
+                'sms': self.sms_delivered,
+                'push': self.push_delivered
+            },
+            'status': 'READ' if self.read_at else 'UNREAD',
+            'read_at': self.read_at.isoformat() if self.read_at else None,
+            'created_at': self.created_at.isoformat(),
+            'expires_at': self.expires_at.isoformat() if self.expires_at else None,
+            'action_url': self.action_url,
+            'is_expired': self.expires_at < datetime.utcnow() if self.expires_at else False
+        }
+        
+        # Parse metadata safely
+        try:
+            res['metadata'] = json.loads(self.metadata_json) if self.metadata_json else {}
+        except Exception:
+            res['metadata'] = {}
+            
+        return res
+
+    @staticmethod
+    def get_priority_weight(priority):
+        """Helper to compare priority levels numerically."""
+        weights = {'CRITICAL': 40, 'HIGH': 30, 'MEDIUM': 20, 'LOW': 10}
+        return weights.get(priority, 0)
+
+class AlertPreference(db.Model):
+    __tablename__ = 'alert_preferences'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    category = db.Column(db.String(50), nullable=False)
+    
+    email_enabled = db.Column(db.Boolean, default=True)
+    sms_enabled = db.Column(db.Boolean, default=False)
+    push_enabled = db.Column(db.Boolean, default=True)
+    websocket_enabled = db.Column(db.Boolean, default=True)
+    
+    min_priority = db.Column(db.String(20), default='LOW')
+
+    def to_dict(self):
+        return {
+            'category': self.category,
+            'email_enabled': self.email_enabled,
+            'sms_enabled': self.sms_enabled,
+            'push_enabled': self.push_enabled,
+            'websocket_enabled': self.websocket_enabled,
+            'min_priority': self.min_priority
+        }
diff --git a/backend/models/audit_log.py b/backend/models/audit_log.py
new file mode 100644
index 00000000..7591517b
--- /dev/null
+++ b/backend/models/audit_log.py
@@ -0,0 +1,109 @@
+from datetime import datetime
+from backend.extensions import db
+import json
+
+class AuditLog(db.Model):
+    __tablename__ = 'audit_logs'
+
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+    action = db.Column(db.String(255), nullable=False)
+    resource_type = db.Column(db.String(100), nullable=True)
+    resource_id = db.Column(db.String(100), nullable=True)
+    
+    # Details of the change
+    old_values = db.Column(db.Text, nullable=True)  # JSON string
+    new_values = db.Column(db.Text, nullable=True)  # JSON string
+    
+    # Request Info
+    ip_address = db.Column(db.String(45), nullable=True)
+    user_agent = db.Column(db.String(512), nullable=True)
+    method = db.Column(db.String(10), nullable=True)
+    url = db.Column(db.String(1024), nullable=True)
+    status_code = db.Column(db.Integer, nullable=True)
+    
+    # Risk Assessment
+    risk_level = db.Column(db.String(20), default='LOW')  # LOW, MEDIUM, HIGH, CRITICAL
+    threat_flag = db.Column(db.Boolean, default=False)
+    
+    timestamp = db.Column(db.DateTime, default=datetime.utcnow)
+    
+    # Meta data for extra context
+    meta_data = db.Column(db.Text, nullable=True) # JSON string
+
+    @property
+    def gravity_score(self) -> int:
+        """Calculates numerical significance for visualization."""
+        base = {'CRITICAL': 100, 'HIGH': 75, 'MEDIUM': 50, 'LOW': 25}
+        score = base.get(self.risk_level, 50)
+        if self.threat_flag: score += 50
+        return score
+
+    @property
+    def value_diff(self) -> Dict[str, Any]:
+        """Calculates the difference between old and new values."""
+        try:
+            old = json.loads(self.old_values) if self.old_values else {}
+            new = json.loads(self.new_values) if self.new_values else {}
+            
+            diff = {}
+            # Simplified diff logic
+            for key in new:
+                if key not in old or old[key] != new[key]:
+                    diff[key] = {"from": old.get(key), "to": new[key]}
+            return diff
+        except Exception:
+            return {}
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'action': self.action,
+            'resource_type': self.resource_type,
+            'resource_id': self.resource_id,
+            'old_values': json.loads(self.old_values) if self.old_values else None,
+            'new_values': json.loads(self.new_values) if self.new_values else None,
+            'diff': self.value_diff,
+            'ip_address': self.ip_address,
+            'method': self.method,
+            'url': self.url,
+            'status_code': self.status_code,
+            'risk_level': self.risk_level,
+            'gravity': self.gravity_score,
+            'threat_flag': self.threat_flag,
+            'timestamp': self.timestamp.isoformat(),
+            'meta_data': json.loads(self.meta_data) if self.meta_data else {}
+        }
+
+    @classmethod
+    def archive_old_logs(cls, days: int = 90):
+        """Prunes historical audit data to manage table size."""
+        cutoff = datetime.utcnow() - timedelta(days=days)
+        deleted = cls.query.filter(cls.timestamp < cutoff).delete()
+        db.session.commit()
+        return deleted
+
+class UserSession(db.Model):
+    __tablename__ = 'user_sessions'
+    
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    session_token = db.Column(db.String(255), unique=True, nullable=False)
+    ip_address = db.Column(db.String(45), nullable=True)
+    user_agent = db.Column(db.String(512), nullable=True)
+    
+    login_time = db.Column(db.DateTime, default=datetime.utcnow)
+    last_activity = db.Column(db.DateTime, default=datetime.utcnow)
+    logout_time = db.Column(db.DateTime, nullable=True)
+    is_active = db.Column(db.Boolean, default=True)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'user_id': self.user_id,
+            'login_time': self.login_time.isoformat(),
+            'last_activity': self.last_activity.isoformat(),
+            'is_active': self.is_active,
+            'ip_address': self.ip_address
+        }
diff --git a/backend/models/media_payload.py b/backend/models/media_payload.py
new file mode 100644
index 00000000..2973d6ce
--- /dev/null
+++ b/backend/models/media_payload.py
@@ -0,0 +1,48 @@
+from datetime import datetime
+from backend.extensions import db
+import json
+
+class MediaPayload(db.Model):
+    __tablename__ = 'media_payloads'
+
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
+    
+    # Payload identification
+    tracking_id = db.Column(db.String(100), unique=True, nullable=False)
+    payload_type = db.Column(db.String(50), nullable=False)  # DISEASE, SOIL, CROP, EQUIPMENT, PROFILE
+    
+    # File details
+    filename = db.Column(db.String(255), nullable=False)
+    file_path = db.Column(db.String(512), nullable=False)
+    file_type = db.Column(db.String(100), nullable=False)
+    file_size = db.Column(db.Integer, nullable=False)
+    
+    # Processing state
+    status = db.Column(db.String(20), default='PENDING')  # PENDING, PROCESSING, COMPLETED, FAILED
+    task_id = db.Column(db.String(100), nullable=True)  # Celery task ID
+    
+    # Extraction results
+    processed_at = db.Column(db.DateTime, nullable=True)
+    result_data = db.Column(db.Text, nullable=True)  # JSON string
+    error_log = db.Column(db.Text, nullable=True)
+    
+    # Metadata context
+    metadata_json = db.Column(db.Text, nullable=True)  # JSON string
+    
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'tracking_id': self.tracking_id,
+            'user_id': self.user_id,
+            'payload_type': self.payload_type,
+            'filename': self.filename,
+            'status': self.status,
+            'task_id': self.task_id,
+            'processed_at': self.processed_at.isoformat() if self.processed_at else None,
+            'result': json.loads(self.result_data) if self.result_data else None,
+            'metadata': json.loads(self.metadata_json) if self.metadata_json else {},
+            'created_at': self.created_at.isoformat()
+        }
diff --git a/backend/services/alert_registry.py b/backend/services/alert_registry.py
new file mode 100644
index 00000000..2ec00263
--- /dev/null
+++ b/backend/services/alert_registry.py
@@ -0,0 +1,234 @@
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List, Any
+from backend.extensions import db, mail, socketio
+from backend.models import Alert, User, AlertPreference
+from backend.utils.logger import logger
+
+class AlertRegistry:
+    """
+    Centralized registry for managing cross-module alerts.
+    Supports asynchronous delivery, priority-based queuing and multi-channel notification.
+    """
+
+    @staticmethod
+    def register_alert(
+        title: str,
+        message: str,
+        category: str,
+        user_id: Optional[int] = None,
+        priority: str = 'MEDIUM',
+        group_key: Optional[str] = None,
+        action_url: Optional[str] = None,
+        metadata: Optional[Dict] = None,
+        ttl_days: int = 30
+    ) -> Optional[Alert]:
+        """
+        Registers a new alert and initiates the multi-channel delivery process.
+        """
+        try:
+            # 1. Create the alert record
+            alert = Alert(
+                user_id=user_id,
+                title=title,
+                message=message,
+                category=category,
+                priority=priority,
+                group_key=group_key,
+                action_url=action_url,
+                metadata_json=json.dumps(metadata) if metadata else None,
+                expires_at=datetime.utcnow() + timedelta(days=ttl_days)
+            )
+            
+            db.session.add(alert)
+            db.session.commit()
+            
+            # 2. Process delivery based on user preferences or global rules
+            AlertRegistry._dispatch_alert(alert)
+            
+            return alert
+        except Exception as e:
+            logger.error(f"Failed to register alert: {str(e)}", exc_info=True)
+            db.session.rollback()
+            return None
+
+    @staticmethod
+    def _dispatch_alert(alert: Alert):
+        """
+        Dispatches alert to various channels based on user preferences.
+        """
+        # If it's a global broadcast, we use default channels
+        if not alert.user_id:
+            AlertRegistry._deliver_websocket(alert)
+            return
+
+        user = User.query.get(alert.user_id)
+        if not user:
+            return
+
+        # Fetch or create default preferences
+        pref = AlertPreference.query.filter_by(
+            user_id=user.id, 
+            category=alert.category
+        ).first()
+
+        # Check if priority meets minimum requirement
+        if pref and Alert.get_priority_weight(alert.priority) < Alert.get_priority_weight(pref.min_priority):
+            logger.info(f"Alert {alert.id} skipped due to priority threshold for user {user.id}")
+            return
+
+        # WebSocket Delivery (Real-time)
+        if not pref or pref.websocket_enabled:
+            AlertRegistry._deliver_websocket(alert)
+
+        # Email Delivery
+        if (not pref or pref.email_enabled) and user.email:
+            AlertRegistry._deliver_email(alert, user.email)
+
+        # SMS Delivery
+        if pref and pref.sms_enabled and hasattr(user, 'phone') and user.phone:
+            AlertRegistry._deliver_sms(alert, user.phone)
+
+    @staticmethod
+    def _deliver_websocket(alert: Alert):
+        """Delivers real-time alert via WebSockets."""
+        try:
+            payload = alert.to_dict()
+            room = f"user_{alert.user_id}" if alert.user_id else "global_alerts"
+            
+            socketio.emit('new_alert', payload, room=room)
+            
+            alert.websocket_delivered = True
+            db.session.commit()
+            logger.info(f"WebSocket alert {alert.id} delivered to {room}")
+        except Exception as e:
+            logger.error(f"WebSocket delivery failed for alert {alert.id}: {str(e)}")
+
+    @staticmethod
+    def _deliver_email(alert: Alert, email: str):
+        """Delivers alert via Email (asynchronous placeholder)."""
+        try:
+            # In a real app, this would be a Celery task
+            # from backend.tasks.email_tasks import send_alert_email
+            # send_alert_email.delay(alert.id, email)
+            
+            # For now, simulate/direct send
+            logger.info(f"Email alert {alert.id} queued for {email}")
+            alert.email_delivered = True
+            db.session.commit()
+        except Exception as e:
+            logger.error(f"Email delivery failed for alert {alert.id}: {str(e)}")
+
+    @staticmethod
+    def _deliver_sms(alert: Alert, phone: str):
+        """Delivers alert via SMS (integration placeholder)."""
+        try:
+            logger.info(f"SMS alert {alert.id} queued for {phone}")
+            alert.sms_delivered = True
+            db.session.commit()
+        except Exception as e:
+            logger.error(f"SMS delivery failed for alert {alert.id}: {str(e)}")
+
+    @staticmethod
+    def mark_as_read(alert_id: int, user_id: int) -> bool:
+        """Marks an alert as read for a specific user."""
+        alert = Alert.query.filter_by(id=alert_id, user_id=user_id).first()
+        if alert:
+            alert.read_at = datetime.utcnow()
+            db.session.commit()
+            return True
+        return False
+
+    @staticmethod
+    def get_user_alerts(user_id: int, unread_only: bool = False, limit: int = 50) -> List[Alert]:
+        """Retrieves alerts for a user with filtering."""
+        query = Alert.query.filter(
+            (Alert.user_id == user_id) | (Alert.user_id.is_(None))
+        )
+        
+        if unread_only:
+            query = query.filter(Alert.read_at.is_(None))
+            
+        return query.order_by(Alert.created_at.desc()).limit(limit).all()
+
+    @staticmethod
+    def get_alert_summary(user_id: int) -> Dict[str, Any]:
+        """
+        Generates a statistical summary of alerts for a user.
+        Useful for dashboard widgets and mobile push payload optimization.
+        """
+        total = Alert.query.filter((Alert.user_id == user_id) | (Alert.user_id.is_(None))).count()
+        unread = Alert.query.filter(
+            ((Alert.user_id == user_id) | (Alert.user_id.is_(None))),
+            Alert.read_at.is_(None)
+        ).count()
+        
+        # Priority breakdown
+        critical = Alert.query.filter_by(user_id=user_id, priority='CRITICAL', read_at=None).count()
+        high = Alert.query.filter_by(user_id=user_id, priority='HIGH', read_at=None).count()
+        
+        # Category distribution
+        categories = db.session.query(
+            Alert.category, db.func.count(Alert.id)
+        ).filter_by(user_id=user_id).group_by(Alert.category).all()
+        
+        return {
+            'total_alerts': total,
+            'unread_count': unread,
+            'critical_count': critical,
+            'high_count': high,
+            'category_distribution': {cat: count for cat, count in categories},
+            'has_unread_critical': critical > 0
+        }
+
+    @staticmethod
+    def aggregate_alerts_by_group(user_id: int, group_key: str) -> List[Alert]:
+        """
+        Retrieves all related alerts within a group to prevent notification fatigue.
+        """
+        return Alert.query.filter_by(user_id=user_id, group_key=group_key).all()
+
+    @staticmethod
+    def delete_alerts_by_group(user_id: int, group_key: str):
+        """
+        Bulk deletes alerts in a specific group (e.g. when an issue is resolved).
+        """
+        try:
+            Alert.query.filter_by(user_id=user_id, group_key=group_key).delete()
+            db.session.commit()
+            return True
+        except Exception:
+            db.session.rollback()
+            return False
+
+    @staticmethod
+    def update_preferences(user_id: int, preferences: List[Dict[str, Any]]):
+        """Updates user alert preferences across categories."""
+        try:
+            for p in preferences:
+                category = p.get('category')
+                if not category:
+                    continue
+                    
+                pref = AlertPreference.query.filter_by(
+                    user_id=user_id, 
+                    category=category
+                ).first()
+                
+                if not pref:
+                    pref = AlertPreference(user_id=user_id, category=category)
+                    db.session.add(pref)
+                
+                pref.email_enabled = p.get('email_enabled', pref.email_enabled)
+                pref.sms_enabled = p.get('sms_enabled', pref.sms_enabled)
+                pref.push_enabled = p.get('push_enabled', pref.push_enabled)
+                pref.websocket_enabled = p.get('websocket_enabled', pref.websocket_enabled)
+                pref.min_priority = p.get('min_priority', pref.min_priority)
+            
+            db.session.commit()
+            return True
+        except Exception as e:
+            logger.error(f"Failed to update preferences: {str(e)}")
+            db.session.rollback()
+            return False
diff --git a/backend/services/audit_service.py b/backend/services/audit_service.py
new file mode 100644
index 00000000..05ea45f7
--- /dev/null
+++ b/backend/services/audit_service.py
@@ -0,0 +1,322 @@
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List
+from flask import request, g
+from backend.extensions import db
+from backend.models import AuditLog, UserSession, User
+from backend.utils.logger import logger
+
+class AuditService:
+    """
+    Centralized service for recording and analyzing user activity logs.
+    Includes threat detection and session management logic.
+    """
+
+    @staticmethod
+    def log_action(
+        action: str,
+        user_id: Optional[int] = None,
+        resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None,
+        old_values: Optional[Dict] = None,
+        new_values: Optional[Dict] = None,
+        meta_data: Optional[Dict] = None,
+        risk_level: str = 'LOW'
+    ) -> AuditLog:
+        """
+        Extracts request context and persists an audit entry.
+        """
+        try:
+            # Capture request context if available
+            ip_address = request.remote_addr if request else None
+            user_agent = request.user_agent.string if request and request.user_agent else None
+            method = request.method if request else None
+            url = request.url if request else None
+            
+            # Use g.user if user_id is not provided
+            if not user_id and hasattr(g, 'user') and g.user:
+                user_id = g.user.id
+
+            # Threat detection logic
+            is_threat, threat_reason = AuditService._detect_threat(action, user_id, ip_address, url)
+            if is_threat:
+                risk_level = 'CRITICAL'
+                if not meta_data: meta_data = {}
+                meta_data['threat_reason'] = threat_reason
+
+            log = AuditLog(
+                user_id=user_id,
+                action=action,
+                resource_type=resource_type,
+                resource_id=resource_id,
+                old_values=json.dumps(old_values) if old_values else None,
+                new_values=json.dumps(new_values) if new_values else None,
+                ip_address=ip_address,
+                user_agent=user_agent,
+                method=method,
+                url=url,
+                risk_level=risk_level,
+                threat_flag=is_threat,
+                meta_data=json.dumps(meta_data) if meta_data else None
+            )
+
+            db.session.add(log)
+            db.session.commit()
+            
+            if is_threat:
+                logger.warning(f"SECURITY THREAT DETECTED: {threat_reason} | Action: {action} | User: {user_id}")
+                # Potentially trigger an alert via CUNAR here
+                from backend.services.alert_registry import AlertRegistry
+                AlertRegistry.register_alert(
+                    title="Security Threat Detected",
+                    message=f"Suspicious activity: {threat_reason} for action '{action}'",
+                    category="SECURITY",
+                    priority="CRITICAL",
+                    user_id=None # Admin broadcast
+                )
+
+            return log
+        except Exception as e:
+            logger.error(f"Audit logging failed: {str(e)}", exc_info=True)
+            db.session.rollback()
+            return None
+
+    @staticmethod
+    def _detect_threat(action: str, user_id: Optional[int], ip: str, url: str) -> (bool, str):
+        """
+        Internal heuristic for detecting suspicious patterns.
+        """
+        # 1. Check for rapid sequence of sensitive actions
+        if action in ['DELETE_USER', 'EXPORT_DATA', 'CHANGE_PERMISSIONS']:
+            recent_count = AuditLog.query.filter(
+                AuditLog.user_id == user_id,
+                AuditLog.action == action,
+                AuditLog.timestamp >= datetime.utcnow() - timedelta(minutes=5)
+            ).count()
+            if recent_count > 5:
+                return True, "Potential automated bulk sensitive operation"
+
+        # 2. Check for SQL Injection patterns in URL (basic)
+        if url and any(pattern in url.lower() for pattern in ["select%20", "union%20all", "drop%20table"]):
+            return True, "SQL Injection pattern detected in URL"
+
+        # 3. Check for multiple failed logins from same IP
+        if action == 'LOGIN_FAILED':
+            recent_fails = AuditLog.query.filter(
+                AuditLog.ip_address == ip,
+                AuditLog.action == 'LOGIN_FAILED',
+                AuditLog.timestamp >= datetime.utcnow() - timedelta(minutes=15)
+            ).count()
+            if recent_fails > 10:
+                return True, "Brute force login attempt suspected"
+
+        return False, ""
+
+    @staticmethod
+    def start_session(user_id: int, token: str) -> UserSession:
+        """Records the start of a new user session."""
+        try:
+            # Inactive previous sessions
+            UserSession.query.filter_by(user_id=user_id, is_active=True).update({'is_active': False, 'logout_time': datetime.utcnow()})
+            
+            session = UserSession(
+                user_id=user_id,
+                session_token=token,
+                ip_address=request.remote_addr if request else None,
+                user_agent=request.user_agent.string if request and request.user_agent else None
+            )
+            db.session.add(session)
+            db.session.commit()
+            return session
+        except Exception as e:
+            logger.error(f"Failed to start session: {str(e)}")
+            return None
+
+    @staticmethod
+    def update_session_activity(token: str):
+        """Updates the last activity timestamp for a session."""
+        session = UserSession.query.filter_by(session_token=token).first()
+        if session:
+            session.last_activity = datetime.utcnow()
+            db.session.commit()
+
+    @staticmethod
+    def end_session(token: str):
+        """Marks a session as terminated."""
+        session = UserSession.query.filter_by(session_token=token).first()
+        if session:
+            session.is_active = False
+            session.logout_time = datetime.utcnow()
+            db.session.commit()
+
+    @staticmethod
+    def get_logs(filters: Dict[str, Any], limit: int = 100, offset: int = 0) -> List[AuditLog]:
+        """Query audit logs with various filters."""
+        query = AuditLog.query
+        
+        if filters.get('user_id'):
+            query = query.filter_by(user_id=filters['user_id'])
+        if filters.get('action'):
+            query = query.filter(AuditLog.action.ilike(f"%{filters['action']}%"))
+        if filters.get('risk_level'):
+            query = query.filter_by(risk_level=filters['risk_level'])
+        if filters.get('threat_only'):
+            query = query.filter_by(threat_flag=True)
+        if filters.get('start_date'):
+            query = query.filter(AuditLog.timestamp >= datetime.fromisoformat(filters['start_date']))
+            
+        return query.order_by(AuditLog.timestamp.desc()).limit(limit).offset(offset).all()
+
+    @staticmethod
+    def analyze_user_behavior(user_id: int, days: int = 7) -> Dict[str, Any]:
+        """
+        Performs behavioral analysis to identify anomalies.
+        Compare current activity against historical norms.
+        """
+        cutoff = datetime.utcnow() - timedelta(days=days)
+        logs = AuditLog.query.filter(AuditLog.user_id == user_id, AuditLog.timestamp >= cutoff).all()
+        
+        if not logs:
+            return {"status": "insufficient_data"}
+
+        # 1. Action frequencies
+        action_counts = {}
+        for log in logs:
+            action_counts[log.action] = action_counts.get(log.action, 0) + 1
+            
+        # 2. Temporal analysis (active hours)
+        active_hours = [log.timestamp.hour for log in logs]
+        avg_hour = sum(active_hours) / len(active_hours)
+        
+        # 3. IP diversity
+        unique_ips = set(log.ip_address for log in logs if log.ip_address)
+        
+        # 4. Security score calculation
+        threat_count = sum(1 for log in logs if log.threat_flag)
+        high_risk_count = sum(1 for log in logs if log.risk_level in ['HIGH', 'CRITICAL'])
+        
+        security_score = 100 - (threat_count * 10) - (high_risk_count * 5) - (len(unique_ips) * 2)
+        
+        return {
+            "user_id": user_id,
+            "analysis_period_days": days,
+            "total_actions": len(logs),
+            "top_actions": sorted(action_counts.items(), key=lambda x: x[1], reverse=True)[:5],
+            "ip_count": len(unique_ips),
+            "security_score": max(0, security_score),
+            "avg_active_hour": round(avg_hour, 1),
+            "anomaly_detected": security_score < 40 or len(unique_ips) > 5
+        }
+
+    @staticmethod
+    def generate_security_report(hours: int = 24) -> Dict[str, Any]:
+        """
+        Generates a comprehensive system-wide security forensic report.
+        """
+        cutoff = datetime.utcnow() - timedelta(hours=hours)
+        total_logs = AuditLog.query.filter(AuditLog.timestamp >= cutoff).count()
+        threats = AuditLog.query.filter(AuditLog.timestamp >= cutoff, AuditLog.threat_flag == True).all()
+        
+        # Identity threats grouped by IP
+        ip_threats = {}
+        for t in threats:
+            if t.ip_address:
+                if t.ip_address not in ip_threats: ip_threats[t.ip_address] = []
+                ip_threats[t.ip_address].append(t.action)
+
+        # Flagged sensitive resources
+        sensitive_ops = AuditLog.query.filter(
+            AuditLog.timestamp >= cutoff,
+            AuditLog.action.in_(['DELETE_USER', 'DATABASE_WIPE', 'CONFIG_CHANGE', 'PERMISSION_GRANT'])
+        ).all()
+
+        return {
+            "report_timestamp": datetime.utcnow().isoformat(),
+            "period_hours": hours,
+            "total_interactions": total_logs,
+            "threat_count": len(threats),
+            "high_risk_source_ips": {ip: len(actions) for ip, actions in ip_threats.items() if len(actions) > 2},
+            "sensitive_operations_performed": [s.to_dict() for s in sensitive_ops],
+            "system_health_status": "CRITICAL" if len(threats) > 50 else "WARNING" if len(threats) > 10 else "SECURE"
+        }
+
+    @staticmethod
+    def detect_session_hijacking(user_id: int, current_ip: str, current_ua: str) -> bool:
+        """
+        Checks for session hijacking indicators like sudden IP or UA switches.
+        """
+        active_session = UserSession.query.filter_by(user_id=user_id, is_active=True).first()
+        if not active_session:
+            return False
+            
+        # If IP changed significantly (e.g. different subnet) or UA changed
+        if active_session.ip_address != current_ip or active_session.user_agent != current_ua:
+            AuditService.log_action(
+                action="SESSION_HIJACK_SUSPICION",
+                user_id=user_id,
+                risk_level='CRITICAL',
+                meta_data={
+                    "old_ip": active_session.ip_address,
+                    "new_ip": current_ip,
+                    "old_ua": active_session.user_agent,
+                    "new_ua": current_ua
+                }
+            )
+            return True
+        return False
+
+    @staticmethod
+    def forensic_search(criteria: Dict[str, Any]) -> List[AuditLog]:
+        """
+        Performs high-complexity multi-vector forensic searches.
+        Used for deeper security investigation.
+        """
+        query = AuditLog.query
+        
+        # 1. IP range search (subnet matching)
+        if criteria.get('ip_prefix'):
+            query = query.filter(AuditLog.ip_address.like(f"{criteria['ip_prefix']}%"))
+            
+        # 2. Risk range search
+        if criteria.get('min_risk'):
+            risk_map = {'LOW': 0, 'MEDIUM': 1, 'HIGH': 2, 'CRITICAL': 3}
+            # This would require a custom hybrid property or SQL mapping
+            # For now simplified filtering
+            if criteria['min_risk'] == 'CRITICAL':
+                query = query.filter_by(risk_level='CRITICAL')
+            elif criteria['min_risk'] == 'HIGH':
+                query = query.filter(AuditLog.risk_level.in_(['HIGH', 'CRITICAL']))
+
+        # 3. Payload content search (Searching inside JSON strings)
+        if criteria.get('payload_query'):
+            query = query.filter(
+                (AuditLog.new_values.ilike(f"%{criteria['payload_query']}%")) |
+                (AuditLog.meta_data.ilike(f"%{criteria['payload_query']}%"))
+            )
+
+        # 4. Temporal correlation (Actions happening within seconds of each other)
+        if criteria.get('correlation_token'):
+            # Logical grouping by some token in meta_data
+            query = query.filter(AuditLog.meta_data.ilike(f"%{criteria['correlation_token']}%"))
+
+        return query.order_by(AuditLog.timestamp.desc()).limit(200).all()
+
+    @staticmethod
+    def export_audit_trail(user_id: Optional[int] = None, format: str = 'json') -> str:
+        """
+        Generates an encrypted or formatted audit trail for compliance.
+        Returns a string representation (JSON or pseudo-CSV).
+        """
+        logs = AuditLog.query.filter_by(user_id=user_id).all() if user_id else AuditLog.query.all()
+        
+        if format == 'json':
+            return json.dumps([log.to_dict() for log in logs], indent=2)
+            
+        elif format == 'csv':
+            # Pseudo-CSV construction
+            header = "id,timestamp,user_id,action,risk_level,ip_address\n"
+            rows = [f"{l.id},{l.timestamp},{l.user_id},{l.action},{l.risk_level},{l.ip_address}" for l in logs]
+            return header + "\n".join(rows)
+            
+        return "Unsupported format"
diff --git a/backend/services/market_service.py b/backend/services/market_service.py
index 464f5447..edbed123 100644
--- a/backend/services/market_service.py
+++ b/backend/services/market_service.py
@@ -113,13 +113,17 @@ def check_watchlist_alerts(updated_prices):
             for watcher in watchers:
                 # Trigger alert if current price is higher than target (Profit opportunity)
                 if price_data['modal_price'] >= watcher.target_price:
-                    msg = f"Alert! {watcher.crop_name} price in {price_data['district']} reached ₹{price_data['modal_price']}, crossing your target of ₹{watcher.target_price}."
+                    msg = f"Profit Opportunity! {watcher.crop_name} price in {price_data['district']} reached ₹{price_data['modal_price']}, crossing your target of ₹{watcher.target_price}."
                     
-                    NotificationService.create_notification(
+                    from backend.services.alert_registry import AlertRegistry
+                    AlertRegistry.register_alert(
                         user_id=watcher.user_id,
                         title="Market Price Alert",
                         message=msg,
-                        notification_type="price_alert"
+                        category="MARKET",
+                        priority="HIGH",
+                        action_url=f"/market?crop={watcher.crop_name}",
+                        group_key=f"price_{watcher.crop_name}_{price_data['district']}"
                     )
                     alerts_triggered.append({
                         "user_id": watcher.user_id,
diff --git a/backend/services/pipeline_service.py b/backend/services/pipeline_service.py
new file mode 100644
index 00000000..d82d5f7c
--- /dev/null
+++ b/backend/services/pipeline_service.py
@@ -0,0 +1,107 @@
+import os
+import uuid
+import json
+from datetime import datetime
+from typing import Optional, Dict, Any
+from werkzeug.utils import secure_filename
+from flask import current_app
+from backend.extensions import db
+from backend.models import MediaPayload
+from backend.utils.validators import DataIntegrityValidator
+from backend.utils.logger import logger
+
+class MediaPipelineService:
+    """
+    Central logic for media ingestion, metadata mapping, and task dispatching.
+    """
+
+    @staticmethod
+    def ingest_payload(
+        file_obj,
+        payload_type: str,
+        user_id: Optional[int] = None,
+        metadata: Optional[Dict] = None
+    ) -> (Optional[MediaPayload], Optional[str]):
+        """
+        Main entry point for uploading and starting the processing pipeline.
+        """
+        try:
+            # 1. Setup Storage Path
+            upload_dir = os.path.join(current_app.config['UPLOAD_FOLDER'], payload_type.lower())
+            os.makedirs(upload_dir, exist_ok=True)
+            
+            # 2. Secure Filename
+            original_filename = secure_filename(file_obj.filename)
+            tracking_id = str(uuid.uuid4())
+            extension = os.path.splitext(original_filename)[1]
+            stored_filename = f"{tracking_id}{extension}"
+            file_path = os.path.join(upload_dir, stored_filename)
+            
+            # 3. Save to Disk temporarily for validation
+            file_obj.save(file_path)
+            
+            # 4. Deep Validation
+            is_valid, error = DataIntegrityValidator.validate_file(file_path, payload_type)
+            if not is_valid:
+                os.remove(file_path)
+                return None, error
+                
+            is_meta_valid, meta_error = DataIntegrityValidator.validate_metadata(metadata or {}, payload_type)
+            if not is_meta_valid:
+                os.remove(file_path)
+                return None, meta_error
+
+            # 5. Create Registry Entry
+            payload = MediaPayload(
+                user_id=user_id,
+                tracking_id=tracking_id,
+                payload_type=payload_type,
+                filename=original_filename,
+                file_path=file_path,
+                file_type=os.path.splitext(file_path)[1],
+                file_size=os.path.getsize(file_path),
+                metadata_json=json.dumps(metadata) if metadata else None
+            )
+            
+            db.session.add(payload)
+            db.session.commit()
+            
+            # 6. Dispatch Asynchronous Processing
+            MediaPipelineService._dispatch_task(payload)
+            
+            return payload, None
+        except Exception as e:
+            logger.error(f"Media ingestion failed: {str(e)}", exc_info=True)
+            return None, str(e)
+
+    @staticmethod
+    def _dispatch_task(payload: MediaPayload):
+        """
+        Triggers the appropriate Celery task based on payload type.
+        """
+        from backend.tasks.processing_tasks import process_media_pipeline
+        task = process_media_pipeline.delay(payload.id)
+        payload.task_id = task.id
+        payload.status = 'PROCESSING'
+        db.session.commit()
+
+    @staticmethod
+    def get_payload_status(tracking_id: str) -> Optional[MediaPayload]:
+        return MediaPayload.query.filter_by(tracking_id=tracking_id).first()
+
+    @staticmethod
+    def attach_result(payload_id: int, result: Dict, status: str = 'COMPLETED', error: str = None):
+        """
+        Callback for tasks to update payload with findings.
+        """
+        payload = MediaPayload.query.get(payload_id)
+        if payload:
+            payload.result_data = json.dumps(result)
+            payload.status = status
+            payload.processed_at = datetime.utcnow()
+            payload.error_log = error
+            db.session.commit()
+            
+            # Trigger real-time update via SocketIO
+            from backend.extensions import socketio
+            socketio.emit('pipeline_update', payload.to_dict(), room=f"user_{payload.user_id}")
diff --git a/backend/services/weather_service.py b/backend/services/weather_service.py
index e4d75bc2..83fbb1b3 100644
--- a/backend/services/weather_service.py
+++ b/backend/services/weather_service.py
@@ -27,6 +27,29 @@ def update_weather_for_location(location):
         
         db.session.add(weather)
         db.session.commit()
+        
+        # Trigger Alerts for Extreme Conditions
+        # Note: In a real app we'd query users in this location
+        from backend.services.alert_registry import AlertRegistry
+        
+        if weather.temperature > 40:
+            AlertRegistry.register_alert(
+                title="Extreme Heat Alert",
+                message=f"Location {location} is experiencing extreme heat ({weather.temperature}°C). Please protect your crops.",
+                category="WEATHER",
+                priority="HIGH",
+                group_key=f"heat_{location}"
+            )
+            
+        if weather.rainfall > 50:
+             AlertRegistry.register_alert(
+                title="Heavy Rainfall Warning",
+                message=f"Intense rainfall detected in {location}. Check drainage systems.",
+                category="WEATHER",
+                priority="CRITICAL",
+                group_key=f"rain_{location}"
+            )
+            
         return weather
 
     @staticmethod
diff --git a/backend/sockets/alert_socket.py b/backend/sockets/alert_socket.py
new file mode 100644
index 00000000..7d2a33b7
--- /dev/null
+++ b/backend/sockets/alert_socket.py
@@ -0,0 +1,43 @@
+from flask_socketio import emit, join_room, leave_room
+from backend.extensions import socketio
+from backend.utils.logger import logger
+
+@socketio.on('subscribe_alerts')
+def handle_subscribe_alerts(data):
+    """
+    Subscribes a user to their private alert room.
+    """
+    user_id = data.get('user_id')
+    if user_id:
+        room = f"user_{user_id}"
+        join_room(room)
+        logger.info(f"User {user_id} subscribed to alert room: {room}")
+        emit('subscription_success', {'room': room})
+    
+    # All users subscribe to global alerts
+    join_room('global_alerts')
+
+@socketio.on('unsubscribe_alerts')
+def handle_unsubscribe_alerts(data):
+    """
+    Unsubscribes a user from their private alert room.
+    """
+    user_id = data.get('user_id')
+    if user_id:
+        room = f"user_{user_id}"
+        leave_room(room)
+        logger.info(f"User {user_id} unsubscribed from alert room: {room}")
+
+@socketio.on('acknowledge_alert')
+def handle_acknowledge_alert(data):
+    """
+    Handles client-side acknowledgement of an alert.
+    """
+    alert_id = data.get('alert_id')
+    user_id = data.get('user_id')
+    
+    if alert_id and user_id:
+        # Here you could potentially call AlertRegistry.mark_as_read
+        # but usually that's better done via a REST API call for reliability
+        logger.info(f"Alert {alert_id} acknowledged by user {user_id}")
+        emit('alert_acknowledged', {'alert_id': alert_id}, room=f"user_{user_id}")
diff --git a/backend/tasks/alert_cleanup.py b/backend/tasks/alert_cleanup.py
new file mode 100644
index 00000000..aec7b55c
--- /dev/null
+++ b/backend/tasks/alert_cleanup.py
@@ -0,0 +1,48 @@
+from datetime import datetime
+from backend.celery_app import celery
+from backend.extensions import db
+from backend.models import Alert
+from backend.utils.logger import logger
+
+@celery.task(name='tasks.cleanup_expired_alerts')
+def cleanup_expired_alerts():
+    """
+    Background task to remove alerts that have passed their expiration date.
+    Runs periodically (e.g., daily).
+    """
+    try:
+        now = datetime.utcnow()
+        expired_count = Alert.query.filter(Alert.expires_at < now).count()
+        
+        if expired_count > 0:
+            Alert.query.filter(Alert.expires_at < now).delete()
+            db.session.commit()
+            logger.info(f"Cleaned up {expired_count} expired alerts.")
+        else:
+            logger.info("No expired alerts to clean up.")
+            
+        return {'status': 'success', 'deleted': expired_count}
+    except Exception as e:
+        logger.error(f"Error during alert cleanup: {str(e)}")
+        db.session.rollback()
+        return {'status': 'error', 'message': str(e)}
+
+@celery.task(name='tasks.archive_old_read_alerts')
+def archive_old_read_alerts(days=30):
+    """
+    Archives or deletes read alerts older than a certain number of days.
+    """
+    try:
+        cutoff = datetime.utcnow() - timedelta(days=days)
+        old_alerts = Alert.query.filter(
+            Alert.read_at.isnot(None), 
+            Alert.read_at < cutoff
+        ).delete()
+        
+        db.session.commit()
+        logger.info(f"Archived {old_alerts} old read alerts.")
+        return {'status': 'success', 'archived': old_alerts}
+    except Exception as e:
+        logger.error(f"Error during alert archiving: {str(e)}")
+        db.session.rollback()
+        return {'status': 'error', 'message': str(e)}
diff --git a/backend/tasks/audit_tasks.py b/backend/tasks/audit_tasks.py
new file mode 100644
index 00000000..2be217d8
--- /dev/null
+++ b/backend/tasks/audit_tasks.py
@@ -0,0 +1,61 @@
+from datetime import datetime, timedelta
+from backend.celery_app import celery_app
+from backend.extensions import db
+from backend.models import AuditLog, UserSession
+from backend.services.audit_service import AuditService
+import logging
+
+logger = logging.getLogger(__name__)
+
+@celery_app.task(name='tasks.purge_stale_sessions')
+def purge_stale_sessions(timeout_hours=24):
+    """
+    Terminates sessions that haven't shown activity for the specified period.
+    """
+    cutoff = datetime.utcnow() - timedelta(hours=timeout_hours)
+    stale_count = UserSession.query.filter(
+        UserSession.is_active == True,
+        UserSession.last_activity < cutoff
+    ).update({
+        'is_active': False, 
+        'logout_time': datetime.utcnow()
+    })
+    
+    db.session.commit()
+    logger.info(f"Purged {stale_count} stale user sessions.")
+    return {'status': 'success', 'purged': stale_count}
+
+@celery_app.task(name='tasks.generate_daily_security_audit')
+def generate_daily_security_audit():
+    """
+    Generates a system-wide security report and logs it as a CRITICAL audit entry.
+    """
+    report = AuditService.generate_security_report(hours=24)
+    
+    # Store the report summary in the audit log itself
+    AuditService.log_action(
+        action="SYSTEM_SECURITY_FORENSIC_REPORT",
+        risk_level="HIGH",
+        meta_data=report
+    )
+    
+    # If high threat count, register a system alert
+    if report['threat_count'] > 20:
+        from backend.services.alert_registry import AlertRegistry
+        AlertRegistry.register_alert(
+            title="High Threat Volume Detected",
+            message=f"Forensic analysis detected {report['threat_count']} security incidents in the last 24h.",
+            category="SECURITY",
+            priority="CRITICAL"
+        )
+        
+    return {'status': 'success', 'threats_found': report['threat_count']}
+
+@celery_app.task(name='tasks.rotate_audit_logs')
+def rotate_audit_logs(retention_days=180):
+    """
+    Background maintenance to prune extremely old logs.
+    """
+    deleted = AuditLog.archive_old_logs(days=retention_days)
+    logger.info(f"Rotated {deleted} old audit log entries.")
+    return {'status': 'success', 'deleted': deleted}
diff --git a/backend/tasks/processing_tasks.py b/backend/tasks/processing_tasks.py
index dc46ebe8..5d5dd4d4 100644
--- a/backend/tasks/processing_tasks.py
+++ b/backend/tasks/processing_tasks.py
@@ -36,3 +36,97 @@ def daily_production_report_task():
         'batches_completed': batch_count,
         'total_kg': float(total_output)
     }
+
+@celery_app.task(name='tasks.process_media_pipeline')
+def process_media_pipeline(payload_id):
+    """
+    Unified dispatcher for background processing of images and data.
+    UDEMP Pipeline Integration.
+    """
+    from backend.models.media_payload import MediaPayload
+    from backend.services.pipeline_service import MediaPipelineService
+    import time
+    
+    payload = MediaPayload.query.get(payload_id)
+    if not payload:
+        return {'status': 'error', 'message': 'Payload not found'}
+
+    try:
+        if payload.payload_type == 'DISEASE':
+            result = _process_disease_image(payload)
+        elif payload.payload_type == 'SOIL':
+            result = _process_soil_data(payload)
+        else:
+            result = {'message': 'No specialized processor found for this type'}
+
+        MediaPipelineService.attach_result(payload_id, result)
+        return {'status': 'success', 'tracking_id': payload.tracking_id}
+        
+    except Exception as e:
+        logger.error(f"Pipeline processing failed for {payload_id}: {str(e)}")
+        from backend.services.pipeline_service import MediaPipelineService
+        MediaPipelineService.attach_result(payload_id, {}, status='FAILED', error=str(e))
+        return {'status': 'failed', 'error': str(e)}
+
+def _process_disease_image(payload):
+    """
+    Integrates with the Disease Prediction module logic.
+    Loads model dynamically to save memory on worker start.
+    """
+    import sys
+    # Add external module path if not in PYTHONPATH
+    module_path = os.path.join(os.getcwd(), 'Disease prediction')
+    if module_path not in sys.path:
+        sys.path.append(module_path)
+        
+    try:
+        from utils import load_keras_model, predict_image_keras
+        
+        # Load model (caching strategy recommended in prod)
+        model_path = os.path.join(module_path, 'model.h5')
+        if not os.path.exists(model_path):
+             # Fallback for dev environment without model file
+             return {
+                 'prediction': 'Simulation: Bacterial Blight',
+                 'confidence': 0.95,
+                 'recommendation': 'Mock: Apply Copper Fungicide',
+                 'note': 'Real model not found at ' + model_path
+             }
+             
+        model = load_keras_model(model_path)
+        prediction, description = predict_image_keras(model, payload.file_path)
+        
+        return {
+            'prediction': prediction,
+            'confidence': 0.99, # Placeholder as utils doesn't return confidence
+            'recommendation': description,
+            'crop_context': 'Detected from Image'
+        }
+    except ImportError:
+        return {'error': 'Disease prediction module unavailable'}
+    except Exception as e:
+        return {'error': f'Inference failed: {str(e)}'}
+
+def _process_soil_data(payload):
+    """
+    Integrates with Soil Classification logic.
+    """
+    import sys
+    # Add external module path
+    module_path = os.path.join(os.getcwd(), 'Soil Classification Model')
+    if module_path not in sys.path:
+        sys.path.append(module_path)
+        
+    try:
+        from main import SoilClassifier
+        
+        classifier = SoilClassifier()
+        # For soil, we might process an image or CSV. 
+        # Assuming payload.file_path points to the input.
+        result = classifier.predict(payload.file_path)
+        
+        return result
+    except ImportError:
+        return {'error': 'Soil classification module unavailable'}
+    except Exception as e:
+        return {'error': f'Classification failed: {str(e)}'}
diff --git a/backend/utils/validators.py b/backend/utils/validators.py
new file mode 100644
index 00000000..f1e4d6ee
--- /dev/null
+++ b/backend/utils/validators.py
@@ -0,0 +1,69 @@
+import os
+import magic
+from typing import List, Optional
+
+class DataIntegrityValidator:
+    """
+    Utility for validating file types, sizes, and structure across the platform.
+    """
+    
+    ALLOWED_EXTENSIONS = {
+        'DISEASE': ['.jpg', '.jpeg', '.png'],
+        'SOIL': ['.jpg', '.jpeg', '.png', '.csv', '.json'],
+        'CROP': ['.jpg', '.jpeg', '.png', '.csv'],
+        'EQUIPMENT': ['.jpg', '.jpeg', '.png', '.pdf']
+    }
+    
+    # 10 MB limit as default
+    MAX_FILE_SIZE = 10 * 1024 * 1024 
+
+    @staticmethod
+    def validate_file(file_path: str, payload_type: str) -> (bool, Optional[str]):
+        """
+        Validates file existence, size, extension, and MIME type.
+        """
+        if not os.path.exists(file_path):
+            return False, "File does not exist"
+            
+        # Size check
+        size = os.path.getsize(file_path)
+        if size > DataIntegrityValidator.MAX_FILE_SIZE:
+            return False, f"File size ({size} bytes) exceeds limit"
+            
+        # Extension check
+        ext = os.path.splitext(file_path)[1].lower()
+        allowed = DataIntegrityValidator.ALLOWED_EXTENSIONS.get(payload_type, [])
+        if ext not in allowed:
+            return False, f"Extension {ext} not allowed for {payload_type}"
+            
+        # MIME type deep check
+        try:
+            mime = magic.from_file(file_path, mime=True)
+            if payload_type in ['DISEASE', 'SOIL', 'CROP'] and 'image' in mime:
+                return True, None
+            if payload_type == 'EQUIPMENT' and ('image' in mime or 'pdf' in mime):
+                return True, None
+            if payload_type in ['SOIL', 'CROP'] and ('text' in mime or 'json' in mime or 'csv' in mime):
+                return True, None
+        except Exception as e:
+            return False, f"MIME validation failed: {str(e)}"
+            
+        return False, f"MIME type {mime} mismatch for {payload_type}"
+
+    @staticmethod
+    def validate_metadata(metadata: dict, payload_type: str) -> (bool, Optional[str]):
+        """
+        Checks for required fields based on payload type.
+        """
+        required_fields = {
+            'DISEASE': ['crop_name'],
+            'SOIL': ['location_lat', 'location_lon'],
+            'CROP': ['variety']
+        }
+        
+        needed = required_fields.get(payload_type, [])
+        for field in needed:
+            if field not in metadata:
+                return False, f"Missing required metadata: {field}"
+                
+        return True, None
diff --git a/js/alert_manager.js b/js/alert_manager.js
new file mode 100644
index 00000000..823ddb9a
--- /dev/null
+++ b/js/alert_manager.js
@@ -0,0 +1,190 @@
+/**
+ * AgriTech Unified Alert Manager
+ * Manages real-time alerts, notifications, and cross-module communications.
+ */
+
+class AlertManager {
+    constructor() {
+        this.socket = null;
+        this.userId = null;
+        this.alerts = [];
+        this.unreadCount = 0;
+        this.containerId = 'alert-notification-hub';
+        this.badgeId = 'alert-badge-count';
+
+        this.init();
+    }
+
+    init() {
+        // Try to get user from global session or local storage
+        const userStr = localStorage.getItem('user');
+        if (userStr) {
+            try {
+                const user = JSON.parse(userStr);
+                this.userId = user.id;
+            } catch (e) {
+                console.error('Failed to parse user data:', e);
+            }
+        }
+
+        // Initialize Socket.IO connection
+        this.socket = typeof io !== 'undefined' ? io() : null;
+        if (this.socket) {
+            this.setupSocketHandlers();
+        } else {
+            console.warn('Socket.IO not found. Real-time alerts disabled.');
+        }
+
+        // Load historical alerts
+        this.fetchAlerts();
+
+        // Setup UI listeners
+        document.addEventListener('DOMContentLoaded', () => {
+            this.updateUI();
+        });
+    }
+
+    setupSocketHandlers() {
+        this.socket.on('connect', () => {
+            console.log('Connected to Alert System');
+            if (this.userId) {
+                this.socket.emit('subscribe_alerts', { user_id: this.userId });
+            } else {
+                this.socket.emit('subscribe_alerts', {}); // Global only
+            }
+        });
+
+        this.socket.on('new_alert', (alert) => {
+            console.log('New Alert Received:', alert);
+            this.handleIncomingAlert(alert);
+        });
+
+        this.socket.on('subscription_success', (data) => {
+            console.log('Subscribed to room:', data.room);
+        });
+    }
+
+    async fetchAlerts() {
+        if (!this.userId) return;
+
+        try {
+            const response = await fetch(`/api/v1/alerts/?user_id=${this.userId}`);
+            if (response.ok) {
+                const data = await response.json();
+                this.alerts = data.alerts || [];
+                this.updateMetadata();
+                this.updateUI();
+            }
+        } catch (error) {
+            console.error('Failed to fetch alerts:', error);
+        }
+    }
+
+    handleIncomingAlert(alert) {
+        // Add to list
+        this.alerts.unshift(alert);
+
+        // Play sound if high priority
+        if (['HIGH', 'CRITICAL'].includes(alert.priority)) {
+            this.playAlertSound();
+        }
+
+        // Show toast
+        this.showToast(alert);
+
+        // Update state
+        this.updateMetadata();
+        this.updateUI();
+    }
+
+    updateMetadata() {
+        this.unreadCount = this.alerts.filter(a => !a.read_at).length;
+    }
+
+    updateUI() {
+        // Update badge
+        const badge = document.getElementById(this.badgeId);
+        if (badge) {
+            badge.textContent = this.unreadCount;
+            badge.style.display = this.unreadCount > 0 ? 'inline-flex' : 'none';
+        }
+
+        // Update list if open
+        const container = document.getElementById(this.containerId);
+        if (container) {
+            this.renderAlertList(container);
+        }
+    }
+
+    renderAlertList(container) {
+        if (this.alerts.length === 0) {
+            container.innerHTML = '<div class="alert-empty">No new alerts</div>';
+            return;
+        }
+
+        const html = this.alerts.map(alert => `
+            <div class="alert-item ${alert.read_at ? 'read' : 'unread'} priority-${alert.priority.toLowerCase()}" 
+                 onclick="alertManager.markAsRead(${alert.id})">
+                <div class="alert-meta">
+                    <span class="alert-category">${alert.category}</span>
+                    <span class="alert-time">${this.formatTime(alert.created_at)}</span>
+                </div>
+                <div class="alert-title">${alert.title}</div>
+                <div class="alert-message">${alert.message}</div>
+                ${alert.action_url ? `<a href="${alert.action_url}" class="alert-action">Take Action</a>` : ''}
+            </div>
+        `).join('');
+
+        container.innerHTML = html;
+    }
+
+    async markAsRead(alertId) {
+        try {
+            const response = await fetch(`/api/v1/alerts/${alertId}/read`, { method: 'POST' });
+            if (response.ok) {
+                const alert = this.alerts.find(a => a.id === alertId);
+                if (alert) {
+                    alert.read_at = new Date().toISOString();
+                    this.updateMetadata();
+                    this.updateUI();
+                }
+            }
+        } catch (error) {
+            console.error('Error marking alert as read:', error);
+        }
+    }
+
+    showToast(alert) {
+        const toast = document.createElement('div');
+        toast.className = `alert-toast priority-${alert.priority.toLowerCase()}`;
+        toast.innerHTML = `
+            <div class="toast-body">
+                <strong>${alert.title}</strong>
+                <p>${alert.message}</p>
+            </div>
+        `;
+        document.body.appendChild(toast);
+
+        setTimeout(() => {
+            toast.classList.add('show');
+            setTimeout(() => {
+                toast.classList.remove('show');
+                setTimeout(() => toast.remove(), 500);
+            }, 5000);
+        }, 100);
+    }
+
+    playAlertSound() {
+        // Audio implementation placeholder
+        console.log('Playing alert sound...');
+    }
+
+    formatTime(isoString) {
+        const date = new Date(isoString);
+        return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    }
+}
+
+// Initialize globally
+const alertManager = new AlertManager();
+window.alertManager = alertManager;
diff --git a/navbar.html b/navbar.html
index e4ba4982..209fa48c 100644
--- a/navbar.html
+++ b/navbar.html
@@ -6,687 +6,687 @@
   <title>Navbar Component</title>
   <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" />
   <style>
-:root {
-  --bg-color: #030712;
-  --text-color: #ffffff;
-  --text-muted: #cbd5e1;
-  --surface-color: rgba(15, 23, 42, 0.9);
-  --section-bg: rgba(30, 41, 59, 0.7);
-  --border-color: #334155;
-  --accent-color: #22c55e;
-  --input-bg: #333333;
-  --input-border: #555555;
-  --btn-bg: #334155;
-  --btn-text: #ffffff;
-  --btn-hover: #475569;
-  --shadow-color: rgba(0, 0, 0, 0.3);
-}
-
-[data-theme="light"] {
-  --bg-color: #f8fafc;
-  --text-color: #0f172a;
-  --text-muted: #475569;
-  --surface-color: rgba(255, 255, 255, 0.95);
-  --section-bg: rgba(241, 245, 249, 0.8);
-  --border-color: #cbd5e1;
-  --accent-color: #16a34a;
-  --input-bg: #ffffff;
-  --input-border: #94a3b8;
-  --btn-bg: #e2e8f0;
-  --btn-text: #0f172a;
-  --btn-hover: #cbd5e1;
-  --shadow-color: rgba(0, 0, 0, 0.1);
-}
-
-* {
-  box-sizing: border-box;
-}
-
-.mobile-menu,
-.mobile-menu-overlay {
-  display: none;
-}
-
-.navbar {
-  position: relative;
-  width: 100%;
-  z-index: 100;
-  background: var(--surface-color);
-  backdrop-filter: blur(10px);
-  padding: 0.9rem 1.5rem;
-  border-bottom: 1px solid var(--border-color);
-  transition: background 0.3s ease, border-color 0.3s ease;
-}
-
-.navbar-content {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  max-width: 100%;
-  margin: 0 auto;
-  gap: 1.5rem;
-  flex-wrap: nowrap;
-}
-
-.brand {
-  display: flex;
-  align-items: center;
-  gap: 10px;
-  flex-shrink: 0;
-  min-width: fit-content;
-}
-
-.brand img {
-  width: 42px;
-  height: 42px;
-  background: white;
-  padding: 5px;
-  border-radius: 8px;
-}
-
-.brand a {
-  color: var(--accent-color);
-  text-decoration: none;
-  font-size: 1.4rem;
-  font-weight: bold;
-  white-space: nowrap;
-}
-
-.hamburger-btn {
-  display: none;
-  background: none;
-  border: none;
-  cursor: pointer;
-  padding: 0.5rem;
-  flex-shrink: 0;
-  z-index: 101;
-}
-
-.hamburger-icon {
-  display: flex;
-  flex-direction: column;
-  gap: 4px;
-}
-
-.bar {
-  width: 25px;
-  height: 3px;
-  background: var(--text-color);
-  border-radius: 2px;
-  transition: all 0.3s ease;
-}
-
-.left-nav {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  flex-shrink: 1;
-  min-width: 0;
-}
-
-.nav-link {
-  font-size: 0.9rem;
-  font-weight: 500;
-  text-decoration: none;
-  color: var(--text-color);
-  position: relative;
-  transition: color 0.3s ease;
-  white-space: nowrap;
-  padding: 0.3rem 0;
-}
-
-.nav-link:hover {
-  color: var(--accent-color);
-}
-
-.nav-link::after {
-  content: "";
-  position: absolute;
-  bottom: 0;
-  left: 0;
-  width: 0;
-  height: 2px;
-  background: var(--accent-color);
-  transition: width 0.3s ease;
-}
-
-.nav-link:hover::after {
-  width: 100%;
-}
-
-.nav-buttons {
-  display: flex;
-  align-items: center;
-  gap: 0.7rem;
-  flex-wrap: nowrap;
-  flex-shrink: 0;
-  min-width: fit-content;
-}
-
-.search-container {
-  position: relative;
-  display: flex;
-  gap: 0.25rem;
-  flex-shrink: 1;
-  min-width: 0;
-}
-
-.search-input {
-  padding: 0.55rem 0.7rem;
-  padding-right: 40px;
-  border-radius: 8px;
-  border: 1px solid var(--input-border);
-  background: transparent;
-  color: var(--text-color);
-  width: 200px;
-  transition: all 0.3s ease;
-  font-size: 0.875rem;
-}
-
-.search-button {
-  position: absolute;
-  right: 0;
-  top: 0;
-  bottom: 0;
-  padding: 0.55rem 0.7rem;
-  background: var(--accent-color);
-  border: none;
-  border-radius: 0 8px 8px 0;
-  color: white;
-  cursor: pointer;
-  width: 40px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-}
-
-.search-input:focus {
-  width: 240px;
-  outline: none;
-  border-color: var(--accent-color);
-}
-
-.services-toggle-container {
-  position: relative;
-}
-
-.services-toggle {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-}
-
-.services-arrow {
-  transition: transform 0.3s;
-  font-size: 0.75rem;
-}
-
-.services-arrow.rotated {
-  transform: rotate(180deg);
-}
-
-.services-dropdown {
-  position: absolute;
-  top: calc(100% + 0.5rem);
-  left: 0;
-  background: var(--surface-color);
-  border: 1px solid var(--border-color);
-  border-radius: 0.5rem;
-  min-width: 250px;
-  padding: 0.5rem;
-  opacity: 0;
-  visibility: hidden;
-  transform: translateY(-10px);
-  transition: all 0.3s ease;
-  z-index: 1000;
-  box-shadow: 0 4px 12px var(--shadow-color);
-}
-
-.services-dropdown.active {
-  opacity: 1;
-  visibility: visible;
-  transform: translateY(0);
-}
-
-.services-list {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-}
-
-.services-list li {
-  margin: 0.25rem 0;
-}
-
-.services-list a {
-  display: flex;
-  align-items: center;
-  gap: 0.6rem;
-  color: var(--text-muted);
-  text-decoration: none;
-  padding: 0.6rem;
-  border-radius: 4px;
-  transition: all 0.2s;
-  font-size: 0.875rem;
-}
-
-.services-list a:hover {
-  background: var(--btn-bg);
-  color: var(--text-color);
-}
-
-.lang-container {
-  position: relative;
-  flex-shrink: 0;
-}
-
-.lang-btn {
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  padding: 0.55rem 0.75rem;
-  background: transparent;
-  border: 1px solid var(--border-color);
-  border-radius: 8px;
-  color: var(--text-color);
-  cursor: pointer;
-  transition: all 0.2s;
-  font-size: 0.875rem;
-  white-space: nowrap;
-}
-
-.lang-btn:hover {
-  border-color: var(--accent-color);
-  background: rgba(34, 197, 94, 0.1);
-}
-
-.lang-dropdown {
-  position: absolute;
-  top: calc(100% + 0.5rem);
-  right: 0;
-  background: var(--surface-color);
-  border: 1px solid var(--border-color);
-  border-radius: 0.5rem;
-  min-width: 130px;
-  padding: 0.5rem;
-  opacity: 0;
-  visibility: hidden;
-  transform: translateY(-10px);
-  transition: all 0.3s ease;
-  z-index: 1000;
-  box-shadow: 0 4px 12px var(--shadow-color);
-  max-height: 300px;
-  overflow-y: auto;
-}
-
-.lang-dropdown.active {
-  opacity: 1;
-  visibility: visible;
-  transform: translateY(0);
-}
-
-.lang-option {
-  display: block;
-  color: var(--text-muted);
-  text-decoration: none;
-  padding: 0.55rem 0.6rem;
-  border-radius: 4px;
-  transition: all 0.2s;
-  cursor: pointer;
-  font-size: 0.875rem;
-}
-
-.lang-option:hover {
-  background: var(--btn-bg);
-  color: var(--text-color);
-}
-
-.theme-toggle {
-  background: transparent;
-  border: 1px solid var(--border-color);
-  color: var(--text-color);
-  padding: 0.55rem 0.75rem;
-  border-radius: 8px;
-  transition: all 0.2s;
-  cursor: pointer;
-  display: flex;
-  align-items: center;
-  gap: 0.5rem;
-  font-size: 0.875rem;
-  white-space: nowrap;
-}
-
-.theme-toggle:hover {
-  border-color: var(--accent-color);
-  background: rgba(34, 197, 94, 0.1);
-}
-
-.theme-toggle i {
-  font-size: 0.9rem;
-}
-
-.btn {
-  padding: 0.55rem 0.85rem;
-  border-radius: 8px;
-  text-decoration: none;
-  font-weight: 500;
-  font-size: 0.875rem;
-  transition: all 0.2s ease;
-  border: none;
-  cursor: pointer;
-  display: inline-flex;
-  align-items: center;
-  gap: 0.4rem;
-  white-space: nowrap;
-  background: var(--btn-bg);
-  color: var(--btn-text);
-  flex-shrink: 0;
-}
-
-.btn:hover {
-  transform: translateY(-2px);
-  box-shadow: 0 4px 12px var(--shadow-color);
-  background: var(--btn-hover);
-}
-
-.btn-primary {
-  background: var(--accent-color);
-  color: white;
-}
-
-.btn-primary:hover {
-  background: #15803d;
-}
-
-.btn-secondary {
-  background: transparent;
-  border: 1px solid var(--border-color);
-  color: var(--text-color);
-}
-
-.btn-secondary:hover {
-  border-color: var(--accent-color);
-  background: rgba(34, 197, 94, 0.1);
-}
-
-/* Responsive Breakpoints */
-@media (max-width: 1400px) {
-  .navbar-content {
-    gap: 1.2rem;
-  }
-
-  .left-nav {
-    gap: 0.85rem;
-  }
-  
-  .nav-link {
-    font-size: 0.875rem;
-  }
-  
-  .search-input {
-    width: 170px;
-  }
-  
-  .search-input:focus {
-    width: 200px;
-  }
-
-  .nav-buttons {
-    gap: 0.6rem;
-  }
-}
-
-@media (max-width: 1200px) {
-  .hamburger-btn {
-    display: block;
-  }
-
-  .left-nav,
-  .nav-buttons {
-    display: none;
-  }
-
-  .navbar-content {
-    justify-content: space-between;
-  }
-
-  .mobile-menu,
-  .mobile-menu-overlay {
-    display: block;
-  }
-
-  .mobile-menu-overlay {
-    position: fixed;
-    inset: 0;
-    background: rgba(0, 0, 0, 0.5);
-    opacity: 0;
-    pointer-events: none;
-    transition: opacity 0.3s ease;
-    z-index: 998;
-  }
-
-  .mobile-menu-overlay.active {
-    opacity: 1;
-    pointer-events: auto;
-  }
-
-  .mobile-menu {
-    position: fixed;
-    top: 0;
-    right: 0;
-    width: 80%;
-    max-width: 320px;
-    height: 100vh;
-    background: var(--surface-color);
-    transform: translateX(100%);
-    transition: transform 0.35s ease;
-    z-index: 999;
-    padding: 1.25rem;
-    overflow-y: auto;
-    border-left: 1px solid var(--border-color);
-  }
-
-  .mobile-menu.active {
-    transform: translateX(0);
-  }
-
-  .mobile-menu-header {
-    display: flex;
-    justify-content: flex-end;
-    border-bottom: 1px solid var(--border-color);
-    padding-bottom: 0.75rem;
-    margin-bottom: 1.25rem;
-  }
-
-  .mobile-close-btn {
-    background: none;
-    border: none;
-    font-size: 1.3rem;
-    color: var(--text-color);
-    cursor: pointer;
-    padding: 0.5rem;
-  }
-
-  .mobile-search {
-    display: flex;
-    margin: 1rem 0;
-    position: relative;
-  }
-
-  .mobile-search-input {
-    flex: 1;
-    padding: 0.7rem;
-    padding-right: 45px;
-    border-radius: 8px;
-    border: 1px solid var(--input-border);
-    background: transparent;
-    color: var(--text-color);
-    width: 100%;
-    font-size: 0.95rem;
-  }
-
-  .mobile-search-btn {
-    position: absolute;
-    right: 0;
-    top: 0;
-    bottom: 0;
-    background: var(--accent-color);
-    border: none;
-    padding: 0.7rem 0.9rem;
-    color: white;
-    border-radius: 0 8px 8px 0;
-    cursor: pointer;
-  }
-
-  .mobile-buttons {
-    margin-bottom: 1.25rem;
-  }
-
-  .mobile-theme-toggle {
-    width: 100%;
-    justify-content: center;
-    margin-bottom: 1.25rem;
-    padding: 0.85rem;
-    font-size: 0.95rem;
-  }
-
-  .mobile-links {
-    display: flex;
-    flex-direction: column;
-    gap: 0.35rem;
-  }
-
-  .mobile-link {
-    display: flex;
-    align-items: center;
-    gap: 0.85rem;
-    padding: 0.85rem 0.7rem;
-    text-decoration: none;
-    color: var(--text-color);
-    border-radius: 8px;
-    transition: background 0.2s;
-    font-size: 1rem;
-  }
-
-  .mobile-link:hover {
-    background: var(--btn-bg);
-  }
-
-  .mobile-link i {
-    width: 22px;
-    text-align: center;
-    font-size: 1rem;
-  }
-
-  .mobile-services-section {
-    display: flex;
-    flex-direction: column;
-  }
-
-  #mobileServicesToggle {
-    justify-content: space-between;
-  }
-
-  #mobileServicesArrow {
-    margin-left: auto;
-    font-size: 0.85rem;
-    transition: transform 0.3s ease;
-  }
-
-  .mobile-services-list {
-    display: none;
-    flex-direction: column;
-    gap: 0.3rem;
-    padding-left: 2.2rem;
-    margin-top: 0.5rem;
-  }
-
-  .mobile-services-list.active {
-    display: flex;
-  }
-
-  .mobile-services-list.active ~ #mobileServicesToggle #mobileServicesArrow {
-    transform: rotate(180deg);
-  }
-
-  .mobile-sublink {
-    display: flex;
-    align-items: center;
-    gap: 0.6rem;
-    padding: 0.7rem 0.6rem;
-    color: var(--text-muted);
-    text-decoration: none;
-    border-radius: 4px;
-    font-size: 0.9rem;
-    transition: background 0.2s, color 0.2s;
-  }
-
-  .mobile-sublink:hover {
-    background: var(--btn-bg);
-    color: var(--text-color);
-  }
-
-  .mobile-footer-links {
-    margin-top: 2rem;
-    border-top: 1px solid var(--border-color);
-    padding-top: 1.25rem;
-    display: flex;
-    flex-direction: column;
-    gap: 0.5rem;
-  }
-
-  .mobile-footer-link {
-    text-decoration: none;
-    color: var(--text-muted);
-    padding: 0.85rem 0.7rem;
-    border-radius: 6px;
-    transition: all 0.2s;
-    display: flex;
-    align-items: center;
-    gap: 0.85rem;
-    font-size: 0.95rem;
-  }
-
-  .mobile-footer-link:hover {
-    background: var(--btn-bg);
-    color: var(--text-color);
-  }
-}
-
-@media (max-width: 768px) {
-  .navbar {
-    padding: 0.85rem 1rem;
-  }
-
-  .brand img {
-    width: 38px;
-    height: 38px;
-  }
-
-  .brand a {
-    font-size: 1.3rem;
-  }
-}
-
-@media (max-width: 480px) {
-  .navbar {
-    padding: 0.75rem 0.85rem;
-  }
-
-  .brand img {
-    width: 35px;
-    height: 35px;
-  }
-
-  .brand a {
-    font-size: 1.2rem;
-  }
-
-  .mobile-menu {
-    width: 85%;
-    max-width: 280px;
-  }
-}
+    :root {
+      --bg-color: #030712;
+      --text-color: #ffffff;
+      --text-muted: #cbd5e1;
+      --surface-color: rgba(15, 23, 42, 0.9);
+      --section-bg: rgba(30, 41, 59, 0.7);
+      --border-color: #334155;
+      --accent-color: #22c55e;
+      --input-bg: #333333;
+      --input-border: #555555;
+      --btn-bg: #334155;
+      --btn-text: #ffffff;
+      --btn-hover: #475569;
+      --shadow-color: rgba(0, 0, 0, 0.3);
+    }
+
+    [data-theme="light"] {
+      --bg-color: #f8fafc;
+      --text-color: #0f172a;
+      --text-muted: #475569;
+      --surface-color: rgba(255, 255, 255, 0.95);
+      --section-bg: rgba(241, 245, 249, 0.8);
+      --border-color: #cbd5e1;
+      --accent-color: #16a34a;
+      --input-bg: #ffffff;
+      --input-border: #94a3b8;
+      --btn-bg: #e2e8f0;
+      --btn-text: #0f172a;
+      --btn-hover: #cbd5e1;
+      --shadow-color: rgba(0, 0, 0, 0.1);
+    }
+
+    * {
+      box-sizing: border-box;
+    }
+
+    .mobile-menu,
+    .mobile-menu-overlay {
+      display: none;
+    }
+
+    .navbar {
+      position: relative;
+      width: 100%;
+      z-index: 100;
+      background: var(--surface-color);
+      backdrop-filter: blur(10px);
+      padding: 0.9rem 1.5rem;
+      border-bottom: 1px solid var(--border-color);
+      transition: background 0.3s ease, border-color 0.3s ease;
+    }
+
+    .navbar-content {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      max-width: 100%;
+      margin: 0 auto;
+      gap: 1.5rem;
+      flex-wrap: nowrap;
+    }
+
+    .brand {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      flex-shrink: 0;
+      min-width: fit-content;
+    }
+
+    .brand img {
+      width: 42px;
+      height: 42px;
+      background: white;
+      padding: 5px;
+      border-radius: 8px;
+    }
+
+    .brand a {
+      color: var(--accent-color);
+      text-decoration: none;
+      font-size: 1.4rem;
+      font-weight: bold;
+      white-space: nowrap;
+    }
+
+    .hamburger-btn {
+      display: none;
+      background: none;
+      border: none;
+      cursor: pointer;
+      padding: 0.5rem;
+      flex-shrink: 0;
+      z-index: 101;
+    }
+
+    .hamburger-icon {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .bar {
+      width: 25px;
+      height: 3px;
+      background: var(--text-color);
+      border-radius: 2px;
+      transition: all 0.3s ease;
+    }
+
+    .left-nav {
+      display: flex;
+      align-items: center;
+      gap: 1rem;
+      flex-shrink: 1;
+      min-width: 0;
+    }
+
+    .nav-link {
+      font-size: 0.9rem;
+      font-weight: 500;
+      text-decoration: none;
+      color: var(--text-color);
+      position: relative;
+      transition: color 0.3s ease;
+      white-space: nowrap;
+      padding: 0.3rem 0;
+    }
+
+    .nav-link:hover {
+      color: var(--accent-color);
+    }
+
+    .nav-link::after {
+      content: "";
+      position: absolute;
+      bottom: 0;
+      left: 0;
+      width: 0;
+      height: 2px;
+      background: var(--accent-color);
+      transition: width 0.3s ease;
+    }
+
+    .nav-link:hover::after {
+      width: 100%;
+    }
+
+    .nav-buttons {
+      display: flex;
+      align-items: center;
+      gap: 0.7rem;
+      flex-wrap: nowrap;
+      flex-shrink: 0;
+      min-width: fit-content;
+    }
+
+    .search-container {
+      position: relative;
+      display: flex;
+      gap: 0.25rem;
+      flex-shrink: 1;
+      min-width: 0;
+    }
+
+    .search-input {
+      padding: 0.55rem 0.7rem;
+      padding-right: 40px;
+      border-radius: 8px;
+      border: 1px solid var(--input-border);
+      background: transparent;
+      color: var(--text-color);
+      width: 200px;
+      transition: all 0.3s ease;
+      font-size: 0.875rem;
+    }
+
+    .search-button {
+      position: absolute;
+      right: 0;
+      top: 0;
+      bottom: 0;
+      padding: 0.55rem 0.7rem;
+      background: var(--accent-color);
+      border: none;
+      border-radius: 0 8px 8px 0;
+      color: white;
+      cursor: pointer;
+      width: 40px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .search-input:focus {
+      width: 240px;
+      outline: none;
+      border-color: var(--accent-color);
+    }
+
+    .services-toggle-container {
+      position: relative;
+    }
+
+    .services-toggle {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+    }
+
+    .services-arrow {
+      transition: transform 0.3s;
+      font-size: 0.75rem;
+    }
+
+    .services-arrow.rotated {
+      transform: rotate(180deg);
+    }
+
+    .services-dropdown {
+      position: absolute;
+      top: calc(100% + 0.5rem);
+      left: 0;
+      background: var(--surface-color);
+      border: 1px solid var(--border-color);
+      border-radius: 0.5rem;
+      min-width: 250px;
+      padding: 0.5rem;
+      opacity: 0;
+      visibility: hidden;
+      transform: translateY(-10px);
+      transition: all 0.3s ease;
+      z-index: 1000;
+      box-shadow: 0 4px 12px var(--shadow-color);
+    }
+
+    .services-dropdown.active {
+      opacity: 1;
+      visibility: visible;
+      transform: translateY(0);
+    }
+
+    .services-list {
+      list-style: none;
+      padding: 0;
+      margin: 0;
+    }
+
+    .services-list li {
+      margin: 0.25rem 0;
+    }
+
+    .services-list a {
+      display: flex;
+      align-items: center;
+      gap: 0.6rem;
+      color: var(--text-muted);
+      text-decoration: none;
+      padding: 0.6rem;
+      border-radius: 4px;
+      transition: all 0.2s;
+      font-size: 0.875rem;
+    }
+
+    .services-list a:hover {
+      background: var(--btn-bg);
+      color: var(--text-color);
+    }
+
+    .lang-container {
+      position: relative;
+      flex-shrink: 0;
+    }
+
+    .lang-btn {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.55rem 0.75rem;
+      background: transparent;
+      border: 1px solid var(--border-color);
+      border-radius: 8px;
+      color: var(--text-color);
+      cursor: pointer;
+      transition: all 0.2s;
+      font-size: 0.875rem;
+      white-space: nowrap;
+    }
+
+    .lang-btn:hover {
+      border-color: var(--accent-color);
+      background: rgba(34, 197, 94, 0.1);
+    }
+
+    .lang-dropdown {
+      position: absolute;
+      top: calc(100% + 0.5rem);
+      right: 0;
+      background: var(--surface-color);
+      border: 1px solid var(--border-color);
+      border-radius: 0.5rem;
+      min-width: 130px;
+      padding: 0.5rem;
+      opacity: 0;
+      visibility: hidden;
+      transform: translateY(-10px);
+      transition: all 0.3s ease;
+      z-index: 1000;
+      box-shadow: 0 4px 12px var(--shadow-color);
+      max-height: 300px;
+      overflow-y: auto;
+    }
+
+    .lang-dropdown.active {
+      opacity: 1;
+      visibility: visible;
+      transform: translateY(0);
+    }
+
+    .lang-option {
+      display: block;
+      color: var(--text-muted);
+      text-decoration: none;
+      padding: 0.55rem 0.6rem;
+      border-radius: 4px;
+      transition: all 0.2s;
+      cursor: pointer;
+      font-size: 0.875rem;
+    }
+
+    .lang-option:hover {
+      background: var(--btn-bg);
+      color: var(--text-color);
+    }
+
+    .theme-toggle {
+      background: transparent;
+      border: 1px solid var(--border-color);
+      color: var(--text-color);
+      padding: 0.55rem 0.75rem;
+      border-radius: 8px;
+      transition: all 0.2s;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-size: 0.875rem;
+      white-space: nowrap;
+    }
+
+    .theme-toggle:hover {
+      border-color: var(--accent-color);
+      background: rgba(34, 197, 94, 0.1);
+    }
+
+    .theme-toggle i {
+      font-size: 0.9rem;
+    }
+
+    .btn {
+      padding: 0.55rem 0.85rem;
+      border-radius: 8px;
+      text-decoration: none;
+      font-weight: 500;
+      font-size: 0.875rem;
+      transition: all 0.2s ease;
+      border: none;
+      cursor: pointer;
+      display: inline-flex;
+      align-items: center;
+      gap: 0.4rem;
+      white-space: nowrap;
+      background: var(--btn-bg);
+      color: var(--btn-text);
+      flex-shrink: 0;
+    }
+
+    .btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 4px 12px var(--shadow-color);
+      background: var(--btn-hover);
+    }
+
+    .btn-primary {
+      background: var(--accent-color);
+      color: white;
+    }
+
+    .btn-primary:hover {
+      background: #15803d;
+    }
+
+    .btn-secondary {
+      background: transparent;
+      border: 1px solid var(--border-color);
+      color: var(--text-color);
+    }
+
+    .btn-secondary:hover {
+      border-color: var(--accent-color);
+      background: rgba(34, 197, 94, 0.1);
+    }
+
+    /* Responsive Breakpoints */
+    @media (max-width: 1400px) {
+      .navbar-content {
+        gap: 1.2rem;
+      }
+
+      .left-nav {
+        gap: 0.85rem;
+      }
+
+      .nav-link {
+        font-size: 0.875rem;
+      }
+
+      .search-input {
+        width: 170px;
+      }
+
+      .search-input:focus {
+        width: 200px;
+      }
+
+      .nav-buttons {
+        gap: 0.6rem;
+      }
+    }
+
+    @media (max-width: 1200px) {
+      .hamburger-btn {
+        display: block;
+      }
+
+      .left-nav,
+      .nav-buttons {
+        display: none;
+      }
+
+      .navbar-content {
+        justify-content: space-between;
+      }
+
+      .mobile-menu,
+      .mobile-menu-overlay {
+        display: block;
+      }
+
+      .mobile-menu-overlay {
+        position: fixed;
+        inset: 0;
+        background: rgba(0, 0, 0, 0.5);
+        opacity: 0;
+        pointer-events: none;
+        transition: opacity 0.3s ease;
+        z-index: 998;
+      }
+
+      .mobile-menu-overlay.active {
+        opacity: 1;
+        pointer-events: auto;
+      }
+
+      .mobile-menu {
+        position: fixed;
+        top: 0;
+        right: 0;
+        width: 80%;
+        max-width: 320px;
+        height: 100vh;
+        background: var(--surface-color);
+        transform: translateX(100%);
+        transition: transform 0.35s ease;
+        z-index: 999;
+        padding: 1.25rem;
+        overflow-y: auto;
+        border-left: 1px solid var(--border-color);
+      }
+
+      .mobile-menu.active {
+        transform: translateX(0);
+      }
+
+      .mobile-menu-header {
+        display: flex;
+        justify-content: flex-end;
+        border-bottom: 1px solid var(--border-color);
+        padding-bottom: 0.75rem;
+        margin-bottom: 1.25rem;
+      }
+
+      .mobile-close-btn {
+        background: none;
+        border: none;
+        font-size: 1.3rem;
+        color: var(--text-color);
+        cursor: pointer;
+        padding: 0.5rem;
+      }
+
+      .mobile-search {
+        display: flex;
+        margin: 1rem 0;
+        position: relative;
+      }
+
+      .mobile-search-input {
+        flex: 1;
+        padding: 0.7rem;
+        padding-right: 45px;
+        border-radius: 8px;
+        border: 1px solid var(--input-border);
+        background: transparent;
+        color: var(--text-color);
+        width: 100%;
+        font-size: 0.95rem;
+      }
+
+      .mobile-search-btn {
+        position: absolute;
+        right: 0;
+        top: 0;
+        bottom: 0;
+        background: var(--accent-color);
+        border: none;
+        padding: 0.7rem 0.9rem;
+        color: white;
+        border-radius: 0 8px 8px 0;
+        cursor: pointer;
+      }
+
+      .mobile-buttons {
+        margin-bottom: 1.25rem;
+      }
+
+      .mobile-theme-toggle {
+        width: 100%;
+        justify-content: center;
+        margin-bottom: 1.25rem;
+        padding: 0.85rem;
+        font-size: 0.95rem;
+      }
+
+      .mobile-links {
+        display: flex;
+        flex-direction: column;
+        gap: 0.35rem;
+      }
+
+      .mobile-link {
+        display: flex;
+        align-items: center;
+        gap: 0.85rem;
+        padding: 0.85rem 0.7rem;
+        text-decoration: none;
+        color: var(--text-color);
+        border-radius: 8px;
+        transition: background 0.2s;
+        font-size: 1rem;
+      }
+
+      .mobile-link:hover {
+        background: var(--btn-bg);
+      }
+
+      .mobile-link i {
+        width: 22px;
+        text-align: center;
+        font-size: 1rem;
+      }
+
+      .mobile-services-section {
+        display: flex;
+        flex-direction: column;
+      }
+
+      #mobileServicesToggle {
+        justify-content: space-between;
+      }
+
+      #mobileServicesArrow {
+        margin-left: auto;
+        font-size: 0.85rem;
+        transition: transform 0.3s ease;
+      }
+
+      .mobile-services-list {
+        display: none;
+        flex-direction: column;
+        gap: 0.3rem;
+        padding-left: 2.2rem;
+        margin-top: 0.5rem;
+      }
+
+      .mobile-services-list.active {
+        display: flex;
+      }
+
+      .mobile-services-list.active~#mobileServicesToggle #mobileServicesArrow {
+        transform: rotate(180deg);
+      }
+
+      .mobile-sublink {
+        display: flex;
+        align-items: center;
+        gap: 0.6rem;
+        padding: 0.7rem 0.6rem;
+        color: var(--text-muted);
+        text-decoration: none;
+        border-radius: 4px;
+        font-size: 0.9rem;
+        transition: background 0.2s, color 0.2s;
+      }
+
+      .mobile-sublink:hover {
+        background: var(--btn-bg);
+        color: var(--text-color);
+      }
+
+      .mobile-footer-links {
+        margin-top: 2rem;
+        border-top: 1px solid var(--border-color);
+        padding-top: 1.25rem;
+        display: flex;
+        flex-direction: column;
+        gap: 0.5rem;
+      }
+
+      .mobile-footer-link {
+        text-decoration: none;
+        color: var(--text-muted);
+        padding: 0.85rem 0.7rem;
+        border-radius: 6px;
+        transition: all 0.2s;
+        display: flex;
+        align-items: center;
+        gap: 0.85rem;
+        font-size: 0.95rem;
+      }
+
+      .mobile-footer-link:hover {
+        background: var(--btn-bg);
+        color: var(--text-color);
+      }
+    }
+
+    @media (max-width: 768px) {
+      .navbar {
+        padding: 0.85rem 1rem;
+      }
+
+      .brand img {
+        width: 38px;
+        height: 38px;
+      }
+
+      .brand a {
+        font-size: 1.3rem;
+      }
+    }
+
+    @media (max-width: 480px) {
+      .navbar {
+        padding: 0.75rem 0.85rem;
+      }
+
+      .brand img {
+        width: 35px;
+        height: 35px;
+      }
+
+      .brand a {
+        font-size: 1.2rem;
+      }
+
+      .mobile-menu {
+        width: 85%;
+        max-width: 280px;
+      }
+    }
 
     .services-dropdown.active {
       opacity: 1;
@@ -801,6 +801,154 @@
       font-size: 0.9rem;
     }
 
+    /* Unified Alert Hub Styles */
+    .alert-hub-container {
+      position: relative;
+      flex-shrink: 0;
+    }
+
+    .alert-bell-btn {
+      background: transparent;
+      border: 1px solid var(--border-color);
+      color: var(--text-color);
+      padding: 0.55rem 0.85rem;
+      border-radius: 8px;
+      cursor: pointer;
+      position: relative;
+      transition: all 0.2s;
+    }
+
+    .alert-bell-btn:hover {
+      border-color: var(--accent-color);
+      background: rgba(34, 197, 94, 0.1);
+    }
+
+    .alert-badge {
+      position: absolute;
+      top: -5px;
+      right: -5px;
+      background: #ef4444;
+      color: white;
+      font-size: 10px;
+      font-weight: bold;
+      width: 18px;
+      height: 18px;
+      border-radius: 50%;
+      display: none;
+      align-items: center;
+      justify-content: center;
+      border: 2px solid var(--bg-color);
+    }
+
+    .alert-dropdown {
+      position: absolute;
+      top: calc(100% + 0.5rem);
+      right: 0;
+      width: 320px;
+      background: var(--surface-color);
+      border: 1px solid var(--border-color);
+      border-radius: 12px;
+      box-shadow: 0 10px 25px var(--shadow-color);
+      opacity: 0;
+      visibility: hidden;
+      transform: translateY(-10px);
+      transition: all 0.3s ease;
+      z-index: 2000;
+      overflow: hidden;
+    }
+
+    .alert-dropdown.active {
+      opacity: 1;
+      visibility: visible;
+      transform: translateY(0);
+    }
+
+    .alert-header {
+      padding: 1rem;
+      border-bottom: 1px solid var(--border-color);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      font-weight: bold;
+    }
+
+    .alert-list-container {
+      max-height: 400px;
+      overflow-y: auto;
+    }
+
+    .alert-item {
+      padding: 1rem;
+      border-bottom: 1px solid var(--border-color);
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+
+    .alert-item:hover {
+      background: var(--btn-bg);
+    }
+
+    .alert-item.unread {
+      background: rgba(34, 197, 94, 0.05);
+      border-left: 3px solid var(--accent-color);
+    }
+
+    .alert-meta {
+      display: flex;
+      justify-content: space-between;
+      font-size: 11px;
+      color: var(--text-muted);
+      margin-bottom: 4px;
+    }
+
+    .alert-title {
+      font-size: 14px;
+      font-weight: 600;
+      color: var(--text-color);
+      margin-bottom: 2px;
+    }
+
+    .alert-message {
+      font-size: 12px;
+      color: var(--text-muted);
+      line-height: 1.4;
+    }
+
+    .alert-toast {
+      position: fixed;
+      bottom: 20px;
+      right: 20px;
+      background: var(--surface-color);
+      border-left: 4px solid var(--accent-color);
+      padding: 1rem;
+      border-radius: 8px;
+      box-shadow: 0 5px 15px rgba(0, 0, 0, 0.3);
+      z-index: 3000;
+      transform: translateX(120%);
+      transition: transform 0.4s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+      min-width: 250px;
+    }
+
+    .alert-toast.show {
+      transform: translateX(0);
+    }
+
+    .priority-critical {
+      border-left-color: #ef4444 !important;
+    }
+
+    .priority-high {
+      border-left-color: #f59e0b !important;
+    }
+
+    .priority-medium {
+      border-left-color: #3b82f6 !important;
+    }
+
+    .priority-low {
+      border-left-color: #10b981 !important;
+    }
+
     .btn {
       padding: 0.5rem 0.85rem;
       border-radius: 8px;
@@ -1026,11 +1174,13 @@
         font-size: 1.1rem;
       }
     }
+
     /* ===== Lighthouse A11Y FIXES ===== */
 
     /* Mobile Register button – fix contrast */
     a.mobile-link.mobile-register {
-      background-color: #166534; /* dark green */
+      background-color: #166534;
+      /* dark green */
       color: #ffffff !important;
       font-weight: 600;
     }
@@ -1053,7 +1203,6 @@
       background-color: #166534 !important;
       color: #ffffff !important;
     }
-
   </style>
 </head>
 
@@ -1126,6 +1275,26 @@
           <span class="theme-label">Light</span>
         </button>
 
+        <div class="alert-hub-container">
+          <button class="alert-bell-btn" id="alertBellBtn" aria-label="Notifications">
+            <i class="fas fa-bell"></i>
+            <span class="alert-badge" id="alert-badge-count">0</span>
+          </button>
+          <div class="alert-dropdown" id="alertDropdown">
+            <div class="alert-header">
+              <span>Alert Registry</span>
+              <a href="#" style="font-size: 12px; color: var(--accent-color); text-decoration: none;">Mark all read</a>
+            </div>
+            <div class="alert-list-container" id="alert-notification-hub">
+              <div class="p-4 text-center text-gray-500">Connecting to registry...</div>
+            </div>
+            <div style="padding: 10px; text-align: center; border-top: 1px solid var(--border-color);">
+              <a href="notifications.html"
+                style="font-size: 12px; color: var(--text-muted); text-decoration: none;">View All Alerts</a>
+            </div>
+          </div>
+        </div>
+
         <a href="login.html" class="btn btn-secondary">Login</a>
         <a href="faq.html" class="btn btn-secondary">FAQ</a>
         <a href="register.html" class="btn btn-primary">Register</a>
@@ -1286,6 +1455,18 @@
       });
     }
   </script> -->
+  <script>
+    const alertBellBtn = document.getElementById('alertBellBtn');
+    const alertDropdown = document.getElementById('alertDropdown');
+    if (alertBellBtn && alertDropdown) {
+      alertBellBtn.addEventListener('click', (e) => {
+        e.stopPropagation();
+        alertDropdown.classList.toggle('active');
+      });
+      document.addEventListener('click', () => alertDropdown.classList.remove('active'));
+    }
+  </script>
+  <script src="js/alert_manager.js"></script>
 </body>
 
 </html>
\ No newline at end of file
diff --git a/notifications.html b/notifications.html
new file mode 100644
index 00000000..9824dc22
--- /dev/null
+++ b/notifications.html
@@ -0,0 +1,368 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Notification Center | AgriTech</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+    <link rel="stylesheet" href="css/style.css">
+    <style>
+        :root {
+            --bg-dark: #0f172a;
+            --surface-dark: #1e293b;
+            --accent-green: #22c55e;
+            --text-primary: #f8fafc;
+            --text-secondary: #94a3b8;
+            --border-color: #334155;
+        }
+
+        body {
+            background-color: var(--bg-dark);
+            color: var(--text-primary);
+            font-family: 'Inter', system-ui, -apple-system, sans-serif;
+            margin: 0;
+            padding: 0;
+        }
+
+        .container {
+            max-width: 1000px;
+            margin: 80px auto;
+            padding: 20px;
+        }
+
+        .header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 30px;
+        }
+
+        .header h1 {
+            font-size: 2rem;
+            margin: 0;
+        }
+
+        .controls {
+            display: flex;
+            gap: 15px;
+        }
+
+        .filter-btn {
+            background: var(--surface-dark);
+            border: 1px solid var(--border-color);
+            color: var(--text-primary);
+            padding: 8px 16px;
+            border-radius: 8px;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+
+        .filter-btn.active {
+            border-color: var(--accent-green);
+            background: rgba(34, 197, 94, 0.1);
+        }
+
+        .alert-card {
+            background: var(--surface-dark);
+            border: 1px solid var(--border-color);
+            border-radius: 12px;
+            padding: 20px;
+            margin-bottom: 15px;
+            display: grid;
+            grid-template-columns: 60px 1fr auto;
+            gap: 20px;
+            align-items: start;
+            transition: transform 0.2s;
+        }
+
+        .alert-card:hover {
+            transform: translateY(-2px);
+            border-color: #475569;
+        }
+
+        .alert-card.unread {
+            border-left: 4px solid var(--accent-green);
+            background: rgba(34, 197, 94, 0.02);
+        }
+
+        .category-icon {
+            width: 50px;
+            height: 50px;
+            background: rgba(255, 255, 255, 0.05);
+            border-radius: 10px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 1.2rem;
+        }
+
+        .category-WEATHER {
+            color: #3b82f6;
+        }
+
+        .category-MARKET {
+            color: #f59e0b;
+        }
+
+        .category-SYSTEM {
+            color: #64748b;
+        }
+
+        .category-FORUM {
+            color: #8b5cf6;
+        }
+
+        .alert-content h3 {
+            margin: 0 0 5px 0;
+            font-size: 1.1rem;
+        }
+
+        .alert-content p {
+            margin: 0;
+            color: var(--text-secondary);
+            line-height: 1.5;
+        }
+
+        .alert-meta {
+            text-align: right;
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+        }
+
+        .priority-badge {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 6px;
+            font-size: 0.75rem;
+            margin-bottom: 10px;
+            font-weight: bold;
+        }
+
+        .priority-CRITICAL {
+            background: #fee2e2;
+            color: #991b1b;
+        }
+
+        .priority-HIGH {
+            background: #ffedd5;
+            color: #9a3412;
+        }
+
+        .priority-MEDIUM {
+            background: #dbeafe;
+            color: #1e40af;
+        }
+
+        .priority-LOW {
+            background: #dcfce7;
+            color: #166534;
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 100px;
+            opacity: 0.5;
+        }
+
+        .settings-panel {
+            margin-top: 50px;
+            padding-top: 30px;
+            border-top: 1px solid var(--border-color);
+        }
+
+        .preference-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 20px;
+            margin-top: 20px;
+        }
+
+        .preference-card {
+            background: var(--surface-dark);
+            border: 1px solid var(--border-color);
+            padding: 20px;
+            border-radius: 12px;
+        }
+
+        .toggle-row {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin: 10px 0;
+        }
+
+        /* Switch UI */
+        .switch {
+            position: relative;
+            display: inline-block;
+            width: 40px;
+            height: 20px;
+        }
+
+        .switch input {
+            opacity: 0;
+            width: 0;
+            height: 0;
+        }
+
+        .slider {
+            position: absolute;
+            cursor: pointer;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background-color: #475569;
+            transition: .4s;
+            border-radius: 34px;
+        }
+
+        .slider:before {
+            position: absolute;
+            content: "";
+            height: 16px;
+            width: 16px;
+            left: 2px;
+            bottom: 2px;
+            background-color: white;
+            transition: .4s;
+            border-radius: 50%;
+        }
+
+        input:checked+.slider {
+            background-color: var(--accent-green);
+        }
+
+        input:checked+.slider:before {
+            transform: translateX(20px);
+        }
+    </style>
+</head>
+
+<body>
+    <!-- Navbar placeholder - In real app, include navbar.html -->
+    <div id="navbar-container"></div>
+
+    <div class="container">
+        <div class="header">
+            <h1>Notification Center</h1>
+            <div class="controls">
+                <button class="filter-btn active">All</button>
+                <button class="filter-btn">Unread</button>
+                <button class="filter-btn">Extreme Weather</button>
+                <button class="filter-btn">Market Updates</button>
+            </div>
+        </div>
+
+        <div id="full-alert-list">
+            <!-- Dynamic Content -->
+            <div class="empty-state">
+                <i class="fas fa-bell-slash fa-3x"></i>
+                <p>You're all caught up!</p>
+            </div>
+        </div>
+
+        <div class="settings-panel">
+            <h2>Alert Preferences</h2>
+            <p>Choose how and when you want to be notified for different categories.</p>
+
+            <div class="preference-grid">
+                <!-- Weather -->
+                <div class="preference-card">
+                    <h3><i class="fas fa-cloud-sun"></i> Weather Alerts</h3>
+                    <div class="toggle-row">
+                        <span>Push Notifications</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                    <div class="toggle-row">
+                        <span>Email Digest</span>
+                        <label class="switch"><input type="checkbox"><span class="slider"></span></label>
+                    </div>
+                    <div class="toggle-row">
+                        <span>SMS Alerts (Critical Only)</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                </div>
+
+                <!-- Market -->
+                <div class="preference-card">
+                    <h3><i class="fas fa-chart-line"></i> Market Intelligence</h3>
+                    <div class="toggle-row">
+                        <span>Real-time Price Alerts</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                    <div class="toggle-row">
+                        <span>Weekly Market Report</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                </div>
+
+                <!-- Security -->
+                <div class="preference-card">
+                    <h3><i class="fas fa-shield-alt"></i> Security & Account</h3>
+                    <div class="toggle-row">
+                        <span>Login Attempts</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                    <div class="toggle-row">
+                        <span>Resource Access</span>
+                        <label class="switch"><input type="checkbox" checked><span class="slider"></span></label>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <script src="/js/alert_manager.js"></script>
+    <script>
+        // Load navbar
+        fetch('navbar.html')
+            .then(res => res.text())
+            .then(html => {
+                document.getElementById('navbar-container').innerHTML = html;
+                // Re-init scripts if needed
+            });
+
+        // Simplified rendering for this page
+        function renderFullList(alerts) {
+            const list = document.getElementById('full-alert-list');
+            if (alerts.length === 0) return;
+
+            list.innerHTML = alerts.map(alert => `
+                <div class="alert-card ${alert.read_at ? '' : 'unread'}">
+                    <div class="category-icon category-${alert.category}">
+                        <i class="fas ${getIcon(alert.category)}"></i>
+                    </div>
+                    <div class="alert-content">
+                        <span class="priority-badge priority-${alert.priority}">${alert.priority}</span>
+                        <h3>${alert.title}</h3>
+                        <p>${alert.message}</p>
+                    </div>
+                    <div class="alert-meta">
+                        <div>${formatDate(alert.created_at)}</div>
+                        <div style="margin-top: 10px">
+                            ${alert.read_at ? '' : `<button onclick="markRead(${alert.id})" class="filter-btn">Mark Read</button>`}
+                        </div>
+                    </div>
+                </div>
+            `).join('');
+        }
+
+        function getIcon(cat) {
+            const icons = { 'WEATHER': 'fa-cloud-meatball', 'MARKET': 'fa-store', 'FORUM': 'fa-comments' };
+            return icons[cat] || 'fa-info-circle';
+        }
+
+        function formatDate(iso) {
+            return new Date(iso).toLocaleDateString('en-IN', {
+                day: 'numeric', month: 'short', hour: '2-digit', minute: '2-digit'
+            });
+        }
+
+        // Hook into alertManager
+        window.alertManager.onUpdate = (alerts) => renderFullList(alerts);
+    </script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/security_utils.py b/security_utils.py
index bac9f0d9..dcc6c50f 100644
--- a/security_utils.py
+++ b/security_utils.py
@@ -180,20 +180,20 @@ def decorated_function(*args, **kwargs):
 
 def log_security_event(event_type, details, user_ip=None):
     """Log security events for audit trail"""
-    if user_ip is None:
-        user_ip = request.remote_addr
+    from backend.services.audit_service import AuditService
     
-    user_email = "anonymous"
+    user_id = None
     if hasattr(request, 'user') and request.user:
-        user_email = request.user.get('email', 'unknown')
-
-    log_entry = f"[{datetime.datetime.now()}] TYPE: {event_type} | IP: {user_ip} | USER: {user_email} | DETAILS: {details}"
-    
-    # Log to our security logger
-    security_logger.warning(log_entry)
+        user_id = request.user.get('id') or request.user.get('user_id')
+
+    AuditService.log_action(
+        action=event_type,
+        user_id=user_id,
+        risk_level='HIGH',
+        meta_data={"details": details, "remote_addr": user_ip or request.remote_addr}
+    )
     
-    # Fallback to print if no handlers configured
-    print(f"SECURITY AUDIT: {log_entry}")
+    security_logger.warning(f"SECURITY EVENT: {event_type} | DETAILS: {details}")
 
 def sanitize_sql_input(value):
     """Sanitize input for SQL queries (use parameterized queries instead)"""