diff --git a/.env.example b/.env.example
index 8a9eb4ad..8b418045 100644
--- a/.env.example
+++ b/.env.example
@@ -87,6 +87,12 @@ TWILIO_PHONE_NUMBER=+1234567890
 # SMS Log Aggregation
 LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
 NEXT_PUBLIC_LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+
+# Error Tracking Configuration
+# External error tracking service endpoint (e.g., Sentry, DataDog, LogRocket)
+ERROR_TRACKING_URL=https://your-error-tracking-service.com/api/errors
+ERROR_TRACKING_API_KEY=your_api_key_here
+
 # Discord OAuth Configuration
 DISCORD_CLIENT_ID=your_discord_client_id
 DISCORD_CLIENT_SECRET=your_discord_client_secret
diff --git a/docs/ERROR_TRACKING.md b/docs/ERROR_TRACKING.md
new file mode 100644
index 00000000..5d1fb96e
--- /dev/null
+++ b/docs/ERROR_TRACKING.md
@@ -0,0 +1,370 @@
+# Error Tracking Documentation
+
+## Overview
+
+The teachLink web application uses a comprehensive error tracking system that combines structured logging with external error monitoring services. This ensures all errors are properly captured, categorized, and reported for debugging and monitoring purposes.
+
+## Architecture
+
+### Components
+
+1. **Error Reporting Service** (`src/services/errorReporting.ts`)
+   - Client-side error collection and reporting
+   - Session tracking with unique session IDs
+   - Breadcrumb collection for user action tracing
+   - Automatic error classification
+
+2. **Error API Endpoint** (`src/app/api/errors/report/route.ts`)
+   - Server-side error reception
+   - Integration with external error tracking services
+   - Structured logging of all error reports
+
+3. **Structured Logging** (`src/lib/logging/`)
+   - Pino-based logging system
+   - Automatic redaction of sensitive data
+   - Multiple transport support (in-memory, HTTP, aggregation)
+   - Context-aware logging with request/correlation IDs
+
+4. **Error Utilities** (`src/utils/errorUtils.ts`)
+   - Error classification (network, validation, auth, etc.)
+   - User-friendly error messages
+   - Retry logic with exponential backoff
+
+## Configuration
+
+### Environment Variables
+
+Add the following to your `.env` file:
+
+```bash
+# Error Tracking Configuration
+# External error tracking service endpoint (e.g., Sentry, DataDog, LogRocket)
+ERROR_TRACKING_URL=https://your-error-tracking-service.com/api/errors
+ERROR_TRACKING_API_KEY=your_api_key_here
+```
+
+### Logging Configuration
+
+```bash
+# Log Level (debug | info | warn | error)
+LOG_LEVEL=info
+NEXT_PUBLIC_LOG_LEVEL=info
+
+# Log Aggregation Endpoint
+LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+NEXT_PUBLIC_LOG_AGGREGATION_URL=https://your-log-aggregation-endpoint.com/logs
+```
+
+## Usage
+
+### Client-Side Error Reporting
+
+```typescript
+import { errorReportingService } from '@/services/errorReporting';
+
+// Report an error with context
+try {
+  await someAsyncOperation();
+} catch (error) {
+  await errorReportingService.reportError(error, {
+    action: 'user_submit_form',
+    userId: 'user-123',
+    additionalContext: { formData: data },
+  });
+}
+
+// Set user context for error tracking
+errorReportingService.setUserId('user-123');
+
+// Add breadcrumbs for user actions
+errorReportingService.reportUserAction('button_click', {
+  buttonId: 'submit-form',
+  page: '/editor',
+});
+
+// Clear user context on logout
+errorReportingService.clearUserId();
+```
+
+### Using the Error Handling Hook
+
+```typescript
+import { useErrorHandling } from '@/hooks/useErrorHandling';
+
+function MyComponent() {
+  const { execute, error, isLoading } = useErrorHandling({
+    maxAttempts: 3,
+    reportErrors: true,
+  });
+
+  const handleSubmit = async () => {
+    const result = await execute(() => apiCall());
+    if (result) {
+      // Success
+    }
+  };
+
+  return <button onClick={handleSubmit}>Submit</button>;
+}
+```
+
+### Server-Side Error Logging
+
+```typescript
+import { createLogger } from '@/lib/logging';
+
+const logger = createLogger('myModule');
+
+// Log errors with context
+logger.error('Operation failed', {
+  context: { userId, operation: 'data_fetch' },
+  error: new Error('Database connection failed'),
+});
+
+// Log warnings
+logger.warn('Deprecated API usage', {
+  context: { endpoint: '/api/v1/old' },
+});
+
+// Log info
+logger.info('User action completed', {
+  context: { action: 'login', userId },
+});
+```
+
+## Error Classification
+
+The system automatically classifies errors into the following types:
+
+- **NETWORK**: Network connectivity issues
+- **VALIDATION**: Input validation errors
+- **AUTHENTICATION**: Authentication failures
+- **AUTHORIZATION**: Permission errors
+- **NOT_FOUND**: Resource not found
+- **SERVER**: Server-side errors (5xx)
+- **TIMEOUT**: Request timeouts
+- **OFFLINE**: Application offline
+- **RATE_LIMIT**: API rate limiting
+- **UNKNOWN**: Unclassified errors
+
+Each classification includes:
+- User-friendly message
+- Action suggestion
+- Retryability flag
+- HTTP status code (if applicable)
+
+## External Service Integration
+
+### Supported Services
+
+The error tracking endpoint supports integration with various external services:
+
+1. **Sentry**
+   ```bash
+   ERROR_TRACKING_URL=https://sentry.io/api/PROJECT_ID/envelope/
+   ERROR_TRACKING_API_KEY=your_sentry_dsn
+   ```
+
+2. **DataDog**
+   ```bash
+   ERROR_TRACKING_URL=https://http-intake.logs.datadoghq.com/api/v2/logs
+   ERROR_TRACKING_API_KEY=your_datadog_api_key
+   ```
+
+3. **LogRocket**
+   ```bash
+   ERROR_TRACKING_URL=https://api.logrocket.com/logs
+   ERROR_TRACKING_API_KEY=your_logrocket_api_key
+   ```
+
+4. **Custom Endpoint**
+   ```bash
+   ERROR_TRACKING_URL=https://your-custom-endpoint.com/errors
+   ERROR_TRACKING_API_KEY=your_api_key
+   ```
+
+### Integration Behavior
+
+- Errors are sent asynchronously without blocking the response
+- Failed sends are logged but don't affect the application
+- Each error report includes:
+  - Error details (type, message, stack trace)
+  - Session and user information
+  - Breadcrumbs (user actions leading to error)
+  - Environment and URL information
+  - Source identifier (`teachLink-web`)
+
+## Testing Error Tracking
+
+### Manual Testing
+
+```typescript
+// Test error reporting
+await errorReportingService.reportError(new Error('Test error'), {
+  test: true,
+});
+
+// Test breadcrumb tracking
+errorReportingService.reportUserAction('test_action', { test: true });
+```
+
+### Verification
+
+1. Check browser console for error logs
+2. Verify logs appear in your log aggregation service
+3. Confirm errors appear in external tracking service (if configured)
+4. Check server logs for `/api/errors/report` endpoint activity
+
+## Best Practices
+
+### 1. Always Report Errors
+
+```typescript
+// Good
+try {
+  await operation();
+} catch (error) {
+  await errorReportingService.reportError(error, { context });
+}
+
+// Bad - silent failures
+try {
+  await operation();
+} catch (error) {
+  console.error(error); // Only console logging
+}
+```
+
+### 2. Provide Context
+
+```typescript
+// Good - rich context
+await errorReportingService.reportError(error, {
+  action: 'submit_form',
+  formId: 'contact-form',
+  userId: currentUser.id,
+  formData: { email, subject },
+});
+
+// Bad - minimal context
+await errorReportingService.reportError(error);
+```
+
+### 3. Set User Context
+
+```typescript
+// On login
+errorReportingService.setUserId(user.id);
+
+// On logout
+errorReportingService.clearUserId();
+```
+
+### 4. Add Breadcrumbs
+
+```typescript
+// Track important user actions
+errorReportingService.reportUserAction('navigation', {
+  from: '/dashboard',
+  to: '/editor',
+});
+
+errorReportingService.reportUserAction('form_submit', {
+  formId: 'contact-form',
+  fields: ['email', 'message'],
+});
+```
+
+### 5. Use Appropriate Log Levels
+
+```typescript
+// Debug - detailed information for debugging
+logger.debug('Function called', { context: { params } });
+
+// Info - general informational messages
+logger.info('User logged in', { context: { userId } });
+
+// Warn - warning messages for potential issues
+logger.warn('Deprecated API used', { context: { endpoint } });
+
+// Error - error messages
+logger.error('Operation failed', { context, error });
+```
+
+## Troubleshooting
+
+### Errors Not Appearing in External Service
+
+1. Verify `ERROR_TRACKING_URL` is set correctly
+2. Check `ERROR_TRACKING_API_KEY` is valid
+3. Review server logs for send failures
+4. Ensure the external service is accessible from your server
+
+### Sensitive Data in Logs
+
+The logging system automatically redacts common sensitive data:
+- Passwords
+- API keys
+- Tokens
+- Email addresses
+- Phone numbers
+- Credit card numbers
+
+If you need additional redaction rules, modify `SENSITIVE_KEYS` in `src/lib/logging/index.ts`.
+
+### High Error Volume
+
+If you're receiving too many error reports:
+
+1. Review error classification to filter expected errors
+2. Add error filtering in `sendToExternalService` function
+3. Adjust sampling rates in external service configuration
+4. Implement error deduplication
+
+## Security Considerations
+
+1. **API Keys**: Never commit API keys to version control
+2. **Sensitive Data**: The logging system automatically redacts sensitive data
+3. **User Privacy**: Avoid logging PII beyond what's necessary for debugging
+4. **Access Control**: Ensure error tracking endpoints are protected
+5. **Data Retention**: Configure appropriate data retention policies in external services
+
+## Monitoring and Alerts
+
+Set up monitoring for:
+
+1. Error rate spikes
+2. New error types appearing
+3. High-frequency errors from specific users
+4. External service send failures
+
+Example monitoring queries:
+- Error rate by type
+- Errors by user ID
+- Errors by URL path
+- External service send success rate
+
+## Migration from console.error
+
+The application has been migrated from `console.error` to structured logging:
+
+**Before:**
+```typescript
+console.error('Error occurred:', error);
+```
+
+**After:**
+```typescript
+logger.error('Error occurred', { error, context: { additionalInfo } });
+```
+
+All existing `console.error` calls in error reporting have been replaced with structured logging using the Pino-based logger.
+
+## Support
+
+For issues or questions about error tracking:
+
+1. Check this documentation
+2. Review error logs in your aggregation service
+3. Consult external service documentation (Sentry, DataDog, etc.)
+4. Open an issue in the project repository
diff --git a/src/app/api/errors/report/route.ts b/src/app/api/errors/report/route.ts
index fcee5e42..fd775ccc 100644
--- a/src/app/api/errors/report/route.ts
+++ b/src/app/api/errors/report/route.ts
@@ -4,6 +4,13 @@ import { withRateLimit } from '@/lib/ratelimit';
 
 const logger = createLogger('errors.report');
 
+// External error tracking service configuration
+const ERROR_TRACKING_URL = process.env.ERROR_TRACKING_URL;
+const ERROR_TRACKING_API_KEY = process.env.ERROR_TRACKING_API_KEY;
+
+/**
+ * Custom client error class for consistent error handling
+ */
 class ClientError extends Error {
   constructor(message: string, name: string = 'ClientError') {
     super(message);
@@ -11,6 +18,58 @@ class ClientError extends Error {
   }
 }
 
+/**
+ * Send error to external tracking service (e.g., Sentry, LogRocket, DataDog)
+ */
+async function sendToExternalService(report: any): Promise<void> {
+  if (!ERROR_TRACKING_URL) {
+    return;
+  }
+
+  try {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    if (ERROR_TRACKING_API_KEY) {
+      headers['Authorization'] = `Bearer ${ERROR_TRACKING_API_KEY}`;
+      headers['X-API-Key'] = ERROR_TRACKING_API_KEY;
+    }
+
+    const response = await fetch(ERROR_TRACKING_URL, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify({
+        ...report,
+        source: 'teachLink-web',
+        timestamp: new Date().toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      logger.warn('Failed to send error to external service', {
+        context: {
+          status: response.status,
+          statusText: response.statusText,
+          service: ERROR_TRACKING_URL,
+        },
+      });
+    } else {
+      logger.info('Error sent to external service successfully', {
+        context: { reportId: report.id, service: ERROR_TRACKING_URL },
+      });
+    }
+  } catch (error) {
+    logger.error('Error sending to external tracking service', {
+      error,
+      context: { service: ERROR_TRACKING_URL },
+    });
+  }
+}
+
+  }
+}
+
 export async function POST(request: NextRequest): Promise<NextResponse> {
   // Rate limit per IP — this endpoint is called by client-side JS and is
   // otherwise open to log-flooding DoS. Use the lower REPORTING tier (10/min).
@@ -42,7 +101,7 @@ export async function POST(request: NextRequest): Promise<NextResponse> {
       error: clientError,
     });
 
-    return addHeaders(NextResponse.json({ ok: true }, { status: 200 }));
+ main
   } catch (err) {
     logger.warn('Failed to process error report', { error: err });
     return addHeaders(NextResponse.json({ ok: false }, { status: 400 }));
diff --git a/src/components/cms/ContentEditor.tsx b/src/components/cms/ContentEditor.tsx
index 10e0975e..a2c1bcd5 100644
--- a/src/components/cms/ContentEditor.tsx
+++ b/src/components/cms/ContentEditor.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import React from 'react';
+import React, { useState, useEffect } from 'react';
 import { RichContentEditor } from '../editor/RichContentEditor';
 import { useCMS } from '@/hooks/useCMS';
 
@@ -15,40 +15,87 @@ interface ContentEditorProps {
  */
 export const ContentEditor: React.FC<ContentEditorProps> = ({ moduleId, lessonId }) => {
   const { course, updateLessonContent } = useCMS();
+  const [lastSaved, setLastSaved] = useState<Date | null>(null);
+  const [saveStatus, setSaveStatus] = useState<'idle' | 'saving' | 'saved' | 'error'>('idle');
 
   // Find the lesson in the course structure
   const currentModule = course.modules.find((m) => m.id === moduleId);
   const lesson = currentModule?.lessons.find((l) => l.id === lessonId);
 
   const handleUpdate = (content: string) => {
+    setSaveStatus('saving');
     updateLessonContent(moduleId, lessonId, content);
+    
+    // Simulate save completion
+    setTimeout(() => {
+      setLastSaved(new Date());
+      setSaveStatus('saved');
+      
+      // Reset to idle after 2 seconds
+      setTimeout(() => {
+        setSaveStatus('idle');
+      }, 2000);
+    }, 500);
   };
 
   if (!lesson) {
     return (
-      <div className="flex items-center justify-center h-full text-gray-500">
+      <div className="flex items-center justify-center h-full text-gray-500" role="status">
         Select a lesson to start editing.
       </div>
     );
   }
 
+  const getStatusText = () => {
+    switch (saveStatus) {
+      case 'saving':
+        return 'Saving...';
+      case 'saved':
+        return 'Saved';
+      case 'error':
+        return 'Save failed';
+      default:
+        return lastSaved ? `Last saved: ${lastSaved.toLocaleTimeString()}` : 'Ready';
+    }
+  };
+
+  const getStatusColor = () => {
+    switch (saveStatus) {
+      case 'saving':
+        return 'bg-yellow-500';
+      case 'saved':
+        return 'bg-green-500';
+      case 'error':
+        return 'bg-red-500';
+      default:
+        return 'bg-gray-400';
+    }
+  };
+
   return (
     <div className="flex flex-col h-full space-y-4">
-      <div className="flex items-center justify-between px-4 py-2 bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
+      <header className="flex items-center justify-between px-4 py-2 bg-gray-50 dark:bg-gray-900 border-b border-gray-200 dark:border-gray-700">
         <h2 className="text-lg font-semibold text-gray-800 dark:text-white">
           Editing: <span className="text-blue-500">{lesson.title}</span>
         </h2>
         <div className="flex items-center space-x-2">
-          <span className="text-xs text-gray-400">
-            Last saved: {new Date().toLocaleTimeString()}
+          <span 
+            aria-live="polite" 
+            aria-atomic="true"
+            className="text-xs text-gray-400"
+          >
+            {getStatusText()}
           </span>
-          <div className="w-2 h-2 bg-green-500 rounded-full animate-pulse" />
+          <div 
+            className={`w-2 h-2 rounded-full ${getStatusColor()} ${saveStatus === 'saving' ? 'animate-pulse' : ''}`}
+            aria-hidden="true"
+          />
         </div>
-      </div>
+      </header>
 
-      <div className="flex-1 overflow-hidden">
+      <main className="flex-1 overflow-hidden">
         <RichContentEditor initialContent={lesson.content} onUpdate={handleUpdate} />
-      </div>
+      </main>
     </div>
   );
 };
diff --git a/src/components/editor/CollaborativeEditingTools.tsx b/src/components/editor/CollaborativeEditingTools.tsx
index 123c7f72..dfe9d22b 100644
--- a/src/components/editor/CollaborativeEditingTools.tsx
+++ b/src/components/editor/CollaborativeEditingTools.tsx
@@ -8,23 +8,31 @@ const COLLABORATORS = [
 ];
 
 export const CollaborativeEditingTools: React.FC = () => {
+  const collaboratorNames = COLLABORATORS.map(c => c.name).join(', ');
+
   return (
-    <div className="flex items-center gap-2">
-      <div className="flex -space-x-2" role="list" aria-label="Active collaborators">
-        {COLLABORATORS.map((user) => (
+    <div className="flex items-center gap-2" role="group" aria-label="Collaborative editing">
+      <div 
+        className="flex -space-x-2" 
+        role="list" 
+        aria-label={`Active collaborators: ${collaboratorNames}`}
+      >
+        {COLLABORATORS.map((user, index) => (
           // eslint-disable-next-line @next/next/no-img-element
           <img
             key={user.id}
             role="listitem"
             src={user.avatar}
-            alt={`${user.name} is editing`}
-            title={`${user.name} is editing`}
-            className="w-8 h-8 rounded-full border-2 border-white dark:border-gray-800"
+            alt={`${user.name}, collaborator ${index + 1} of ${COLLABORATORS.length}`}
+            title={user.name}
+            className="w-8 h-8 rounded-full border-2 border-white dark:border-gray-800 focus:outline-none focus:ring-2 focus:ring-blue-500"
+            tabIndex={0}
           />
         ))}
       </div>
       <span
-        aria-label={`${COLLABORATORS.length} active collaborators`}
+        role="status"
+        aria-live="polite"
         className="text-xs text-green-500 font-medium px-2 py-1 bg-green-100 dark:bg-green-900 rounded-full"
       >
         {COLLABORATORS.length} active
diff --git a/src/components/editor/ContentTemplateLibrary.tsx b/src/components/editor/ContentTemplateLibrary.tsx
index 33180bbb..4a2b7409 100644
--- a/src/components/editor/ContentTemplateLibrary.tsx
+++ b/src/components/editor/ContentTemplateLibrary.tsx
@@ -15,47 +15,44 @@ export const ContentTemplateLibrary: React.FC<ContentTemplateLibraryProps> = ({
   const getIcon = (id: string) => {
     switch (id) {
       case 'lesson-header':
-        return <BookOpen className="w-4 h-4" />;
+        return <BookOpen className="w-4 h-4" aria-hidden="true" />;
       case 'code-block':
-        return <Layout className="w-4 h-4" />;
+        return <Layout className="w-4 h-4" aria-hidden="true" />;
       case 'quiz-block':
-        return <ListChecks className="w-4 h-4" />;
+        return <ListChecks className="w-4 h-4" aria-hidden="true" />;
       case 'video-placeholder':
-        return <FileVideo className="w-4 h-4" />;
+        return <FileVideo className="w-4 h-4" aria-hidden="true" />;
       default:
-        return <Layout className="w-4 h-4" />;
+        return <Layout className="w-4 h-4" aria-hidden="true" />;
     }
   };
 
   return (
     <aside
-      aria-labelledby={headingId}
-      className="p-4 bg-gray-50 dark:bg-gray-900 border-l border-gray-200 dark:border-gray-700 h-full w-64 hidden lg:block"
-    >
-      <h3
-        id={headingId}
-        className="font-semibold text-sm text-gray-500 uppercase mb-4 tracking-wider"
-      >
+
         Templates
-      </h3>
-      <div className="space-y-2">
-        {TEMPLATES.map((template) => (
-          <button
-            key={template.id}
-            onClick={() => insertTemplate(editor, template.id)}
-            aria-label={`Insert ${template.name} template: ${template.description}`}
-            className="w-full flex items-center gap-3 p-3 text-left rounded-lg bg-white dark:bg-gray-800 hover:bg-blue-50 dark:hover:bg-gray-700 border border-gray-200 dark:border-gray-700 transition-colors group"
-          >
-            <div className="text-gray-500 group-hover:text-blue-500" aria-hidden="true">
-              {getIcon(template.id)}
-            </div>
-            <div>
-              <div className="font-medium text-sm">{template.name}</div>
-              <div className="text-xs text-gray-400 truncate w-32">{template.description}</div>
-            </div>
-          </button>
-        ))}
-      </div>
+      </h2>
+      <nav aria-label="Template selection">
+        <ul className="space-y-2" role="list">
+          {TEMPLATES.map((template) => (
+            <li key={template.id}>
+              <button
+                onClick={() => insertTemplate(editor, template.id)}
+                aria-label={`Insert ${template.name} template: ${template.description}`}
+                className="w-full flex items-center gap-3 p-3 text-left rounded-lg bg-white dark:bg-gray-800 hover:bg-blue-50 dark:hover:bg-gray-700 border border-gray-200 dark:border-gray-700 transition-colors group focus:outline-none focus:ring-2 focus:ring-blue-500"
+              >
+                <div className="text-gray-500 group-hover:text-blue-500">
+                  {getIcon(template.id)}
+                </div>
+                <div>
+                  <div className="font-medium text-sm">{template.name}</div>
+                  <div className="text-xs text-gray-400 truncate w-32">{template.description}</div>
+                </div>
+              </button>
+            </li>
+          ))}
+        </ul>
+      </nav>
     </aside>
   );
 };
diff --git a/src/components/editor/MediaEmbedder.tsx b/src/components/editor/MediaEmbedder.tsx
index fa051ae1..751a2574 100644
--- a/src/components/editor/MediaEmbedder.tsx
+++ b/src/components/editor/MediaEmbedder.tsx
@@ -1,4 +1,4 @@
-import React, { useId, useState } from 'react';
+main
 import { Image as ImageIcon, Youtube as YoutubeIcon } from 'lucide-react';
 import { sanitizeUrl } from '@/utils/sanitize';
 
@@ -12,10 +12,71 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
   const [url, setUrl] = useState('');
   const [type, setType] = useState<'image' | 'youtube'>('image');
   const [urlError, setUrlError] = useState('');
-  const id = useId();
-  const dialogTitleId = `${id}-title`;
-  const errorId = `${id}-error`;
-  const inputId = `${id}-url`;
+import { useEffect, useRef, useId } from 'react';
+
+const id = useId();
+const dialogTitleId = `${id}-title`;
+const errorId = `${id}-error`;
+const inputId = `${id}-url`;
+
+const dialogRef = useRef<HTMLDivElement>(null);
+const triggerButtonRef = useRef<HTMLButtonElement>(null);
+
+// Focus trap implementation
+useEffect(() => {
+  if (!isOpen) return;
+
+  const dialog = dialogRef.current;
+  if (!dialog) return;
+
+  const focusableElements = dialog.querySelectorAll(
+    'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])'
+  );
+  const firstElement = focusableElements[0] as HTMLElement;
+  const lastElement = focusableElements[focusableElements.length - 1] as HTMLElement;
+
+  // Focus first element when dialog opens
+  firstElement?.focus();
+
+  const handleTab = (e: KeyboardEvent) => {
+    if (e.key !== 'Tab') return;
+
+    if (e.shiftKey) {
+      if (document.activeElement === firstElement) {
+        e.preventDefault();
+        lastElement?.focus();
+      }
+    } else {
+      if (document.activeElement === lastElement) {
+        e.preventDefault();
+        firstElement?.focus();
+      }
+    }
+  };
+
+  const handleEscape = (e: KeyboardEvent) => {
+    if (e.key === 'Escape') {
+      setIsOpen(false);
+      triggerButtonRef.current?.focus();
+    }
+  };
+
+  document.addEventListener('keydown', handleTab);
+  document.addEventListener('keydown', handleEscape);
+
+  return () => {
+    document.removeEventListener('keydown', handleTab);
+    document.removeEventListener('keydown', handleEscape);
+  };
+}, [isOpen]);
+
+// Return focus to trigger button when dialog closes
+useEffect(() => {
+  if (!isOpen && triggerButtonRef.current) {
+    triggerButtonRef.current.focus();
+  }
+}, [isOpen]);
+
 
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
@@ -34,11 +95,17 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
     setIsOpen(false);
   };
 
+  const handleCancel = () => {
+    setUrl('');
+    setUrlError('');
+    setIsOpen(false);
+  };
+
   if (!isOpen) {
     return (
       <div className="flex gap-2">
         <button
-          type="button"
+
           onClick={() => {
             setType('image');
             setIsOpen(true);
@@ -72,7 +139,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
       aria-labelledby={dialogTitleId}
       className="fixed inset-0 z-50 flex items-center justify-center bg-black/50"
     >
-      <div className="bg-white dark:bg-gray-800 p-6 rounded-lg shadow-lg w-96">
+      <div ref={dialogRef} className="bg-white dark:bg-gray-800 p-6 rounded-lg shadow-lg w-96">
         <h3 id={dialogTitleId} className="text-lg font-bold mb-4">
           Add {type === 'image' ? 'Image' : 'YouTube Video'}
         </h3>
@@ -91,6 +158,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
             placeholder={`Enter ${type} URL...`}
             className="w-full p-2 border rounded mb-1 dark:bg-gray-700 dark:border-gray-600"
             aria-describedby={errorId}
+            aria-invalid={!!urlError}
             required
           />
           <p
@@ -104,7 +172,7 @@ export const MediaEmbedder: React.FC<MediaEmbedderProps> = ({ onAddImage, onAddY
           <div className="flex justify-end gap-2">
             <button
               type="button"
-              onClick={() => setIsOpen(false)}
+              onClick={handleCancel}
               className="px-4 py-2 text-gray-600 hover:bg-gray-100 rounded"
             >
               Cancel
diff --git a/src/components/editor/RichContentEditor.tsx b/src/components/editor/RichContentEditor.tsx
index 491297fd..bd8f0461 100644
--- a/src/components/editor/RichContentEditor.tsx
+++ b/src/components/editor/RichContentEditor.tsx
@@ -1,4 +1,4 @@
-import React, { useId } from 'react';
+
 import { EditorContent } from '@tiptap/react';
 import {
   Bold,
@@ -12,6 +12,7 @@ import {
   Redo,
   Heading1,
   Heading2,
+  Keyboard,
 } from 'lucide-react';
 import { useContentEditor } from '@/hooks/useContentEditor';
 import { MediaEmbedder } from './MediaEmbedder';
@@ -39,6 +40,66 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
     onUpdate,
   });
 
+  // Keyboard shortcuts
+  useEffect(() => {
+    if (!editor) return;
+
+    const handleKeyDown = (e: KeyboardEvent) => {
+      // Don't trigger shortcuts when typing in input fields
+      if (
+        e.target instanceof HTMLInputElement ||
+        e.target instanceof HTMLTextAreaElement
+      ) {
+        return;
+      }
+
+      // Ctrl/Cmd + B: Bold
+      if ((e.ctrlKey || e.metaKey) && e.key === 'b') {
+        e.preventDefault();
+        editor.chain().focus().toggleBold().run();
+      }
+
+      // Ctrl/Cmd + I: Italic
+      if ((e.ctrlKey || e.metaKey) && e.key === 'i') {
+        e.preventDefault();
+        editor.chain().focus().toggleItalic().run();
+      }
+
+      // Ctrl/Cmd + U: Underline (if supported)
+      if ((e.ctrlKey || e.metaKey) && e.key === 'u') {
+        e.preventDefault();
+        editor.chain().focus().toggleStrike().run();
+      }
+
+      // Ctrl/Cmd + K: Insert link (placeholder)
+     if ((e.ctrlKey || e.metaKey) && e.key === 'k') {
+        e.preventDefault();
+        // Future: Add link insertion dialog
+      }
+
+      // Ctrl/Cmd + Z: Undo
+      if ((e.ctrlKey || e.metaKey) && e.key === 'z' && !e.shiftKey) {
+        e.preventDefault();
+        editor.chain().focus().undo().run();
+      }
+
+      // Ctrl/Cmd + Shift + Z: Redo
+      if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key === 'z') {
+        e.preventDefault();
+        editor.chain().focus().redo().run();
+      }
+
+      // Ctrl/Cmd + Y: Redo (alternative)
+      if ((e.ctrlKey || e.metaKey) && e.key === 'y') {
+        e.preventDefault();
+        editor.chain().focus().redo().run();
+      }
+    };
+
+    document.addEventListener('keydown', handleKeyDown);
+    return () => document.removeEventListener('keydown', handleKeyDown);
+  }, [editor]);
+
   if (!editor) {
     return null;
   }
@@ -77,42 +138,30 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
       className="flex h-[calc(100vh-100px)] rounded-xl border border-gray-200 bg-white shadow-sm dark:border-gray-700 dark:bg-gray-800 overflow-hidden"
     >
       <div className="flex flex-col flex-1 w-full min-w-0">
-        <div className="sr-only">
-          <h2 id={editorTitleId}>Post editor</h2>
-          <p id={editorDescriptionId}>
-            Use the formatting toolbar before the editor to style post content. The editor supports
-            multiline text, headings, lists, quotes, code blocks, images, and YouTube embeds.
-          </p>
-        </div>
-        {/* Toolbar */}
-        <div
-          id={toolbarId}
-          role="toolbar"
-          aria-label="Text formatting"
-          aria-controls={editorRegionId}
+
           className="flex items-center justify-between p-2 border-b border-gray-200 dark:border-gray-700 bg-gray-50 dark:bg-gray-900 overflow-x-auto"
         >
           <div className="flex items-center gap-1">
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleBold().run()}
               isActive={editor.isActive('bold')}
-              title="Bold"
+              title="Bold (Ctrl+B)"
             >
-              <Bold className="w-4 h-4" />
+              <Bold className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleItalic().run()}
               isActive={editor.isActive('italic')}
-              title="Italic"
+              title="Italic (Ctrl+I)"
             >
-              <Italic className="w-4 h-4" />
+              <Italic className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleStrike().run()}
               isActive={editor.isActive('strike')}
-              title="Strike"
+              title="Strikethrough (Ctrl+U)"
             >
-              <Strikethrough className="w-4 h-4" />
+              <Strikethrough className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -120,14 +169,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('heading', { level: 1 })}
               title="Heading 1"
             >
-              <Heading1 className="w-4 h-4" />
+              <Heading1 className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleHeading({ level: 2 }).run()}
               isActive={editor.isActive('heading', { level: 2 })}
               title="Heading 2"
             >
-              <Heading2 className="w-4 h-4" />
+              <Heading2 className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -135,14 +184,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('bulletList')}
               title="Bullet List"
             >
-              <List className="w-4 h-4" />
+              <List className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleOrderedList().run()}
               isActive={editor.isActive('orderedList')}
               title="Ordered List"
             >
-              <ListOrdered className="w-4 h-4" />
+              <ListOrdered className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <ToolbarButton
@@ -150,14 +199,14 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
               isActive={editor.isActive('codeBlock')}
               title="Code Block"
             >
-              <CodeIcon className="w-4 h-4" />
+              <CodeIcon className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().toggleBlockquote().run()}
               isActive={editor.isActive('blockquote')}
-              title="Quote"
+              title="Blockquote"
             >
-              <Quote className="w-4 h-4" />
+              <Quote className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <div className="w-px h-6 bg-gray-300 dark:bg-gray-700 mx-1" aria-hidden="true" />
             <MediaEmbedder onAddImage={addImage} onAddYoutube={addYoutubeVideo} />
@@ -165,26 +214,26 @@ export const RichContentEditor: React.FC<RichContentEditorProps> = ({
             <ToolbarButton
               onClick={() => editor.chain().focus().undo().run()}
               disabled={!editor.can().undo()}
-              title="Undo"
+              title="Undo (Ctrl+Z)"
             >
-              <Undo className="w-4 h-4" />
+              <Undo className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
             <ToolbarButton
               onClick={() => editor.chain().focus().redo().run()}
               disabled={!editor.can().redo()}
-              title="Redo"
+              title="Redo (Ctrl+Y)"
             >
-              <Redo className="w-4 h-4" />
+              <Redo className="w-4 h-4" aria-hidden="true" />
             </ToolbarButton>
           </div>
 
-          <div className="ml-4">
+          <div className="ml-4 flex items-center gap-2">
             <CollaborativeEditingTools />
           </div>
-        </div>
+        </nav>
 
         {/* Editor Content */}
-        <div id={editorRegionId} className="flex-1 overflow-y-auto bg-white dark:bg-gray-800">
+
           <EditorContent editor={editor} className="h-full p-8" />
         </div>
       </div>
diff --git a/src/components/social/ActivityFeed.tsx b/src/components/social/ActivityFeed.tsx
index b0723e0b..c3135c66 100644
--- a/src/components/social/ActivityFeed.tsx
+++ b/src/components/social/ActivityFeed.tsx
@@ -1,9 +1,20 @@
 'use client';
 import Image from 'next/image';
-import { useEffect, useRef } from 'react';
+import { useCallback, useMemo, useRef } from 'react';
 import { UserCircle } from 'lucide-react';
 import { useActivityFeed } from '@/hooks/useSocialFeatures';
 import { getRelativeTime, groupActivitiesByDate } from '@/utils/socialUtils';
+import AutoSizer from 'react-virtualized-auto-sizer';
+import { VariableSizeList as List } from 'react-window';
+import type { CSSProperties } from 'react';
+import type { Activity } from '@/utils/socialUtils';
+
+const HEADER_HEIGHT = 32;
+const ROW_HEIGHT = 64;
+
+type Row =
+  | { type: 'header'; date: string }
+  | { type: 'activity'; activity: Activity };
 
 function Skeleton() {
   return (
@@ -23,96 +34,139 @@ interface ActivityFeedProps {
 
 export default function ActivityFeed({ userId }: ActivityFeedProps) {
   const { activities, loadMore, loading, hasMore } = useActivityFeed(userId);
-  const sentinelRef = useRef<HTMLDivElement>(null);
-
-  // Trigger loadMore when sentinel enters viewport
-  useEffect(() => {
-    const el = sentinelRef.current;
-    if (!el) return;
-    const observer = new IntersectionObserver(
-      ([entry]) => {
-        if (entry.isIntersecting) loadMore();
-      },
-      { threshold: 0.1 },
-    );
-    observer.observe(el);
-    return () => observer.disconnect();
-  }, [loadMore]);
-
-  const grouped = groupActivitiesByDate(activities);
+  const listRef = useRef<List>(null);
 
-  return (
-    <div className="bg-white dark:bg-gray-900 rounded-xl border border-gray-200 dark:border-gray-700">
-      <div className="p-4 border-b border-gray-200 dark:border-gray-700">
-        <h3 className="font-semibold text-gray-900 dark:text-white">Activity</h3>
-      </div>
+  // Flatten grouped activities into a virtualizable row list with date headers
+  const rows: Row[] = useMemo(() => {
+    const grouped = groupActivitiesByDate(activities);
+    const result: Row[] = [];
+    for (const [date, items] of Object.entries(grouped)) {
+      result.push({ type: 'header', date });
+      for (const activity of items) {
+        result.push({ type: 'activity', activity });
+      }
+    }
+    return result;
+  }, [activities]);
 
-      <div className="divide-y divide-gray-100 dark:divide-gray-800">
-        {loading && activities.length === 0 && (
-          <div className="px-4">
-            {Array.from({ length: 5 }).map((_, i) => (
-              <Skeleton key={i} />
-            ))}
-          </div>
-        )}
+  const rowCount = rows.length;
+
+  const getRowHeight = useCallback(
+    (index: number) =>
+      rows[index]?.type === 'header' ? HEADER_HEIGHT : ROW_HEIGHT,
+    [rows],
+  );
 
-        {Object.entries(grouped).map(([date, items]) => (
-          <div key={date}>
+  const rowRenderer = useCallback(
+    ({ index, style }: { index: number; style: CSSProperties }) => {
+      const row = rows[index];
+      if (!row) return null;
+
+      if (row.type === 'header') {
+        return (
+          <div style={style}>
             <p className="px-4 py-2 text-xs font-semibold text-gray-500 dark:text-gray-400 uppercase tracking-wide bg-gray-50 dark:bg-gray-800/50">
-              {date}
+              {row.date}
             </p>
-            {items.map((activity) => (
-              <div key={activity.id} className="flex gap-3 px-4 py-3">
-                {activity.actorAvatar ? (
-                  <Image
-                    src={activity.actorAvatar}
-                    alt={activity.actorName}
-                    width={36}
-                    height={36}
-                    className="w-9 h-9 rounded-full object-cover shrink-0"
-                  />
-                ) : (
-                  <UserCircle className="w-9 h-9 text-gray-400 shrink-0" />
-                )}
-                <div className="flex-1 min-w-0">
-                  <p className="text-sm text-gray-900 dark:text-white">
-                    <span className="font-medium">{activity.actorName}</span>{' '}
-                    <span className="text-gray-600 dark:text-gray-400">{activity.action}</span>
-                    {activity.targetTitle && (
-                      <>
-                        {' '}
-                        <span className="font-medium">{activity.targetTitle}</span>
-                      </>
-                    )}
-                  </p>
-                  <p className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">
-                    {getRelativeTime(activity.createdAt)}
-                  </p>
-                </div>
-              </div>
-            ))}
           </div>
-        ))}
-
-        {/* Infinite scroll sentinel */}
-        {hasMore && <div ref={sentinelRef} className="h-4" />}
+        );
+      }
 
-        {loading && activities.length > 0 && (
-          <div className="px-4">
-            <Skeleton />
+      const activity = row.activity;
+      return (
+        <div style={style} className="flex gap-3 px-4 py-3">
+          {activity.actorAvatar ? (
+            <Image
+              src={activity.actorAvatar}
+              alt={activity.actorName}
+              width={36}
+              height={36}
+              className="w-9 h-9 rounded-full object-cover shrink-0"
+            />
+          ) : (
+            <UserCircle className="w-9 h-9 text-gray-400 shrink-0" />
+          )}
+          <div className="flex-1 min-w-0">
+            <p className="text-sm text-gray-900 dark:text-white">
+              <span className="font-medium">{activity.actorName}</span>{' '}
+              <span className="text-gray-600 dark:text-gray-400">{activity.action}</span>
+              {activity.targetTitle && (
+                <>
+                  {' '}
+                  <span className="font-medium">{activity.targetTitle}</span>
+                </>
+              )}
+            </p>
+            <p className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">
+              {getRelativeTime(activity.createdAt)}
+            </p>
           </div>
-        )}
+        </div>
+      );
+    },
+    [rows],
+  );
 
-        {!loading && !hasMore && activities.length > 0 && (
-          <p className="py-4 text-center text-xs text-gray-400">No more activity</p>
-        )}
+  const handleItemsRendered = useCallback(
+    ({ visibleStopIndex }: { visibleStopIndex: number }) => {
+      if (hasMore && !loading && visibleStopIndex >= rowCount - 5) {
+        loadMore();
+      }
+    },
+    [hasMore, loading, rowCount, loadMore],
+  );
 
-        {!loading && activities.length === 0 && (
-          <p className="py-8 text-center text-sm text-gray-500 dark:text-gray-400">
-            No activity yet.
-          </p>
-        )}
+  return (
+    <div className="bg-white dark:bg-gray-900 rounded-xl border border-gray-200 dark:border-gray-700">
+      <div className="p-4 border-b border-gray-200 dark:border-gray-700">
+        <h3 className="font-semibold text-gray-900 dark:text-white">Activity</h3>
       </div>
+
+      {loading && activities.length === 0 && (
+        <div className="px-4">
+          {Array.from({ length: 5 }).map((_, i) => (
+            <Skeleton key={i} />
+          ))}
+        </div>
+      )}
+
+      {!loading && activities.length === 0 && (
+        <p className="py-8 text-center text-sm text-gray-500 dark:text-gray-400">
+          No activity yet.
+        </p>
+      )}
+
+      {activities.length > 0 && (
+        <div className="divide-y divide-gray-100 dark:divide-gray-800" style={{ height: '60vh' }}>
+          <AutoSizer>
+            {({ height, width }: { height: number; width: number }) => (
+              <List
+                ref={listRef}
+                height={height}
+                width={width}
+                itemCount={rowCount}
+                itemSize={getRowHeight}
+                onItemsRendered={handleItemsRendered}
+                overscanCount={5}
+              >
+                {rowRenderer}
+              </List>
+            )}
+          </AutoSizer>
+        </div>
+      )}
+
+      {loading && activities.length > 0 && (
+        <div className="px-4 border-t border-gray-100 dark:border-gray-800">
+          <Skeleton />
+        </div>
+      )}
+
+      {!loading && !hasMore && activities.length > 0 && (
+        <p className="py-4 text-center text-xs text-gray-400 border-t border-gray-100 dark:border-gray-800">
+          No more activity
+        </p>
+      )}
     </div>
   );
-}
+}
\ No newline at end of file
diff --git a/src/components/social/__tests__/socialFeatures.test.tsx b/src/components/social/__tests__/socialFeatures.test.tsx
index af8e5abd..1668acda 100644
--- a/src/components/social/__tests__/socialFeatures.test.tsx
+++ b/src/components/social/__tests__/socialFeatures.test.tsx
@@ -17,6 +17,29 @@ vi.mock('next/router', () => ({
   useRouter: () => ({ push: vi.fn(), query: {} }),
 }));
 
+// Mock react-window's VariableSizeList to render all children inline
+vi.mock('react-window', () => ({
+  VariableSizeList: vi.fn(({ children, height, width, itemCount, itemSize, overscanCount, onItemsRendered }) => {
+    // Call onItemsRendered to simulate the list rendering all items
+    if (onItemsRendered) {
+      onItemsRendered({ visibleStopIndex: itemCount - 1 });
+    }
+    // Render each item by calling the children render prop
+    const items: React.ReactNode[] = [];
+    for (let i = 0; i < itemCount; i++) {
+      const style = { height: typeof itemSize === 'function' ? itemSize(i) : itemSize, width, position: 'absolute' as const, top: 0, left: 0 };
+      items.push(children({ index: i, style }));
+    }
+    return <div style={{ height, width }}>{items}</div>;
+  }),
+  FixedSizeList: vi.fn(() => null),
+}));
+
+// Mock react-virtualized-auto-sizer to provide non-zero dimensions
+vi.mock('react-virtualized-auto-sizer', () => ({
+  default: vi.fn(({ children }) => children({ height: 600, width: 400 })),
+}));
+
 // ─── Imports after mocks ───────────────────────────────────────────────────────
 
 import { apiClient } from '@/lib/api';
diff --git a/src/services/errorReporting.ts b/src/services/errorReporting.ts
index 9e8cbbaa..4e046ba7 100644
--- a/src/services/errorReporting.ts
+++ b/src/services/errorReporting.ts
@@ -6,7 +6,6 @@
 import { formatErrorForLogging } from '@/utils/errorUtils';
 import { createLogger } from '@/lib/logging';
 
-const logger = createLogger('error-reporting');
 
 export interface ErrorReport {
   id: string;
@@ -37,6 +36,9 @@ class ErrorReportingService {
     this.sessionId = this.generateSessionId();
     this.isProduction = typeof process !== 'undefined' && process.env?.NODE_ENV === 'production';
     this.setupGlobalErrorHandlers();
+    logger.info('ErrorReportingService initialized', {
+      context: { sessionId: this.sessionId, isProduction: this.isProduction },
+    });
   }
 
   /**
@@ -96,10 +98,6 @@ class ErrorReportingService {
   async reportError(error: any, context?: Record<string, any>): Promise<ErrorReport> {
     const report = this.createErrorReport(error, context);
 
-    // Log to console in development
-    if (!this.isProduction) {
-      logger.error('Error Report', { error: report });
-    }
 
     // Send to error tracking service (e.g., Sentry, LogRocket)
     if (this.isProduction) {
@@ -145,7 +143,7 @@ class ErrorReportingService {
       });
 
       if (!response.ok) {
-        logger.error('Failed to send error report', { status: response.statusText });
+
       }
     } catch (err) {
       logger.error('Error sending error report', { error: err });
diff --git a/src/workers/__tests__/sms-cluster-worker.test.ts b/src/workers/__tests__/sms-cluster-worker.test.ts
index 8a1adc96..a4340225 100644
--- a/src/workers/__tests__/sms-cluster-worker.test.ts
+++ b/src/workers/__tests__/sms-cluster-worker.test.ts
@@ -1,5 +1,11 @@
 import cluster from 'cluster';
-import { startSMSClusterWorker } from '../sms-cluster-worker';
+import { 
+  startSMSClusterWorker, 
+  sanitizeAndValidateSMS, 
+  getSecurityEvents,
+  getQueueSize,
+  getRateLimitStatus 
+} from '../sms-cluster-worker';
 
 jest.mock('cluster', () => ({
   isPrimary: true,
@@ -14,41 +20,172 @@ jest.mock('os', () => ({
 describe('SMS Cluster Worker', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    // Clear security events before each test
+    const events = getSecurityEvents();
+    events.length = 0;
   });
 
-  it('should fork a worker for each CPU if primary', () => {
-    // Override cluster.isPrimary just in case
-    Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+  describe('Cluster Management', () => {
+    it('should fork a worker for each CPU if primary', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
 
-    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
 
-    startSMSClusterWorker();
+      startSMSClusterWorker();
 
-    expect(cluster.fork).toHaveBeenCalledTimes(4);
-    expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining('Setting up cluster with 4 workers'),
-    );
+      expect(cluster.fork).toHaveBeenCalledTimes(4);
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Setting up cluster with 4 workers'),
+      );
 
-    consoleSpy.mockRestore();
+      consoleSpy.mockRestore();
+    });
+
+    it('should bind an exit handler to auto-heal workers', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+
+      startSMSClusterWorker();
+
+      expect(cluster.on).toHaveBeenCalledWith('exit', expect.any(Function));
+    });
+
+    it('should execute worker logic if not primary', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: false, configurable: true });
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+
+      startSMSClusterWorker();
+
+      expect(cluster.fork).not.toHaveBeenCalled();
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Worker'));
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should set worker resource limits', () => {
+      Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+
+      startSMSClusterWorker();
+
+      expect(cluster.fork).toHaveBeenCalledWith(
+        expect.objectContaining({
+          WORKER_ID: expect.any(Number),
+          NODE_OPTIONS: expect.stringContaining('--max-old-space-size=512'),
+        })
+      );
+    });
   });
 
-  it('should bind an exit handler to auto-heal workers', () => {
-    Object.defineProperty(cluster, 'isPrimary', { value: true, configurable: true });
+  describe('Input Validation', () => {
+    it('should validate correct phone numbers', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', 'Test message');
+      expect(result.valid).toBe(true);
+      expect(result.sanitized).toBeDefined();
+    });
+
+    it('should reject invalid phone number format', () => {
+      const result = sanitizeAndValidateSMS('5551234567', 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('Invalid phone number format');
+    });
 
-    startSMSClusterWorker();
+    it('should reject phone numbers that are too long', () => {
+      const result = sanitizeAndValidateSMS('+155512345678901234567', 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('too long');
+    });
 
-    expect(cluster.on).toHaveBeenCalledWith('exit', expect.any(Function));
+    it('should reject non-string phone numbers', () => {
+      const result = sanitizeAndValidateSMS(1234567890 as any, 'Test message');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('must be a string');
+    });
+
+    it('should reject empty messages', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', '');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('cannot be empty');
+    });
+
+    it('should reject messages that are too long', () => {
+      const longMessage = 'a'.repeat(2000);
+      const result = sanitizeAndValidateSMS('+15551234567', longMessage);
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('too long');
+    });
+
+    it('should sanitize message content', () => {
+      const result = sanitizeAndValidateSMS('+15551234567', '<script>alert("xss")</script>');
+      expect(result.valid).toBe(true);
+      expect(result.sanitized?.message).not.toContain('<script>');
+    });
+  });
+
+  describe('Rate Limiting', () => {
+    it('should allow messages within rate limit', () => {
+      for (let i = 0; i < 50; i++) {
+        const result = sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+        expect(result.valid).toBe(true);
+      }
+    });
+
+    it('should enforce rate limit after threshold', () => {
+      // Send 100 messages (should hit the limit)
+      for (let i = 0; i < 100; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+
+      // 101st message should be rate limited
+      const result = sanitizeAndValidateSMS('+15551234567', 'Test message 100');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain('Rate limit exceeded');
+    });
+
+    it('should track rate limit status correctly', () => {
+      for (let i = 0; i < 50; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+
+      const status = getRateLimitStatus('+15551234567');
+      expect(status.remaining).toBeLessThanOrEqual(50);
+      expect(status.resetTime).toBeGreaterThan(Date.now());
+    });
   });
 
-  it('should execute worker logic if not primary', () => {
-    Object.defineProperty(cluster, 'isPrimary', { value: false, configurable: true });
-    const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+  describe('Security Event Logging', () => {
+    it('should log validation failures', () => {
+      sanitizeAndValidateSMS('invalid', 'Test message');
+      const events = getSecurityEvents();
+      
+      expect(events.length).toBeGreaterThan(0);
+      expect(events[events.length - 1].type).toBe('validation_failure');
+    });
 
-    startSMSClusterWorker();
+    it('should log rate limit exceeded events', () => {
+      for (let i = 0; i < 101; i++) {
+        sanitizeAndValidateSMS('+15551234567', `Test message ${i}`);
+      }
+      
+      const events = getSecurityEvents();
+      const rateLimitEvents = events.filter(e => e.type === 'rate_limit_exceeded');
+      expect(rateLimitEvents.length).toBeGreaterThan(0);
+    });
 
-    expect(cluster.fork).not.toHaveBeenCalled();
-    expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Worker'));
+    it('should limit security event history size', () => {
+      // Generate more than 1000 events
+      for (let i = 0; i < 1100; i++) {
+        sanitizeAndValidateSMS(`+155512345${i % 100}`, `Test message ${i}`);
+      }
+      
+      const events = getSecurityEvents();
+      expect(events.length).toBeLessThanOrEqual(1000);
+    });
+  });
 
-    consoleSpy.mockRestore();
+  describe('Queue Management', () => {
+    it('should return current queue size', () => {
+      const size = getQueueSize();
+      expect(typeof size).toBe('number');
+      expect(size).toBeGreaterThanOrEqual(0);
+    });
   });
 });
diff --git a/src/workers/sms-cluster-worker.ts b/src/workers/sms-cluster-worker.ts
index 1289e3a6..f020121e 100644
--- a/src/workers/sms-cluster-worker.ts
+++ b/src/workers/sms-cluster-worker.ts
@@ -1,18 +1,112 @@
 import cluster from 'cluster';
 import os from 'os';
-import { sendSMS } from '../utils/notificationUtils'; // Assuming we have this or we'll mock it
-import { createLogger } from '../lib/logging';
 
-const logger = createLogger('sms-cluster-worker');
 
 const numCPUs = os.cpus().length;
 
-// Mock Queue implementation
+// Security Configuration
+const SECURITY_CONFIG = {
+  MAX_QUEUE_SIZE: 1000,
+  MAX_MESSAGE_LENGTH: 1600,
+  MAX_PHONE_NUMBER_LENGTH: 20,
+  RATE_LIMIT_WINDOW_MS: 60000, // 1 minute
+  RATE_LIMIT_MAX_PER_WINDOW: 100,
+  IP_RATE_LIMIT_WINDOW_MS: 60000, // 1 minute
+  IP_RATE_LIMIT_MAX_PER_WINDOW: 200,
+  WORKER_MAX_MEMORY_MB: 512,
+  WORKER_TIMEOUT_MS: 30000,
+  CIRCUIT_BREAKER_THRESHOLD: 5,
+  CIRCUIT_BREAKER_TIMEOUT_MS: 300000, // 5 minutes
+  DEDUPLICATION_WINDOW_MS: 10000, // 10 seconds
+  HEALTH_CHECK_INTERVAL_MS: 30000, // 30 seconds
+  MAX_HEALTH_CHECK_FAILURES: 3,
+};
+
+// Phone number validation regex (E.164 format)
+const PHONE_NUMBER_REGEX = /^\+[1-9]\d{1,14}$/;
+
+// Rate limiting tracker
+const rateLimitTracker = new Map<string, number[]>();
+
+// Security event logger
+interface SecurityEvent {
+  type: 'validation_failure' | 'rate_limit_exceeded' | 'queue_full' | 'worker_timeout' | 'blacklisted_phone' | 'blocked_content' | 'circuit_breaker_opened' | 'circuit_breaker_closed' | 'duplicate_message' | 'health_check_failed';
+  timestamp: number;
+  details: string;
+  workerId?: number;
+  severity: 'low' | 'medium' | 'high' | 'critical';
+  ipAddress?: string;
+}
+
+const securityEvents: SecurityEvent[] = [];
+
+// Phone number blacklist and whitelist
+const PHONE_BLACKLIST = new Set<string>([
+  // Add blacklisted numbers here
+]);
+
+const PHONE_WHITELIST = new Set<string>([
+  // Add whitelisted numbers here (if whitelist mode is enabled)
+]);
+const WHITELIST_MODE_ENABLED = false;
+
+// Blocked content patterns (regex patterns)
+const BLOCKED_CONTENT_PATTERNS = [
+  /\b(viagra|cialis|porn|xxx|casino|lottery|winner)\b/gi,
+  /\b(bitcoin|crypto|investment|profit|guaranteed)\b/gi,
+  /http(s?):\/\/[^\s/$.?#].[^\s]*/gi, // Block URLs
+];
+
+// IP-based rate limiting tracker
+const ipRateLimitTracker = new Map<string, number[]>();
+
+// Circuit breaker state
+interface CircuitBreakerState {
+  failureCount: number;
+  lastFailureTime: number;
+  isOpen: boolean;
+}
+const circuitBreakerState: CircuitBreakerState = {
+  failureCount: 0,
+  lastFailureTime: 0,
+  isOpen: false,
+};
+
+// Message deduplication tracker
+const messageDeduplicationTracker = new Map<string, number>();
+
+// Worker health check state
+const workerHealthState = new Map<number, { failures: number; lastCheck: number }>();
+
+function logSecurityEvent(event: SecurityEvent) {
+  securityEvents.push(event);
+  const severityPrefix = {
+    low: '[INFO]',
+    medium: '[WARN]',
+    high: '[ERROR]',
+    critical: '[CRITICAL]',
+  }[event.severity];
+  console.error(`${severityPrefix} [SECURITY] ${event.type}: ${event.details}`);
+  if (securityEvents.length > 1000) {
+    securityEvents.shift(); // Keep only last 1000 events
+  }
+}
+
+// Mock Queue implementation with security controls
 class SMSQueue {
-  private messages: { to: string; message: string }[] = [];
+  private messages: { to: string; message: string; timestamp: number }[] = [];
 
-  enqueue(to: string, message: string) {
-    this.messages.push({ to, message });
+  enqueue(to: string, message: string): boolean {
+    if (this.messages.length >= SECURITY_CONFIG.MAX_QUEUE_SIZE) {
+      logSecurityEvent({
+        type: 'queue_full',
+        timestamp: Date.now(),
+        details: `Queue rejected message. Current size: ${this.messages.length}`,
+      });
+      return false;
+    }
+    this.messages.push({ to, message, timestamp: Date.now() });
+    return true;
   }
 
   dequeue() {
@@ -26,43 +120,303 @@ class SMSQueue {
 
 const smsQueue = new SMSQueue();
 
-// Seed queue for demonstration
+// Input validation and sanitization
+function validatePhoneNumber(phone: string): { valid: boolean; reason?: string } {
+  if (typeof phone !== 'string') {
+    return { valid: false, reason: 'Phone number must be a string' };
+  }
+  if (phone.length > SECURITY_CONFIG.MAX_PHONE_NUMBER_LENGTH) {
+    return { valid: false, reason: 'Phone number too long' };
+  }
+  if (!PHONE_NUMBER_REGEX.test(phone)) {
+    return { valid: false, reason: 'Invalid phone number format (must be E.164)' };
+  }
+  return { valid: true };
+}
+
+function validateMessage(message: string): { valid: boolean; reason?: string } {
+  if (typeof message !== 'string') {
+    return { valid: false, reason: 'Message must be a string' };
+  }
+  if (message.length > SECURITY_CONFIG.MAX_MESSAGE_LENGTH) {
+    return { valid: false, reason: 'Message too long' };
+  }
+  if (message.trim().length === 0) {
+    return { valid: false, reason: 'Message cannot be empty' };
+  }
+  return { valid: true };
+}
+
+function checkRateLimit(phoneNumber: string, ipAddress?: string): boolean {
+  const now = Date.now();
+  const timestamps = rateLimitTracker.get(phoneNumber) || [];
+  
+  // Remove timestamps outside the rate limit window
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS);
+  
+  if (validTimestamps.length >= SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW) {
+    logSecurityEvent({
+      type: 'rate_limit_exceeded',
+      timestamp: now,
+      details: `Rate limit exceeded for ${phoneNumber}: ${validTimestamps.length} requests in window`,
+      severity: 'high',
+      ipAddress,
+    });
+    return false;
+  }
+  
+  validTimestamps.push(now);
+  rateLimitTracker.set(phoneNumber, validTimestamps);
+  return true;
+}
+
+function checkIPRateLimit(ipAddress: string): boolean {
+  const now = Date.now();
+  const timestamps = ipRateLimitTracker.get(ipAddress) || [];
+  
+  // Remove timestamps outside the rate limit window
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.IP_RATE_LIMIT_WINDOW_MS);
+  
+  if (validTimestamps.length >= SECURITY_CONFIG.IP_RATE_LIMIT_MAX_PER_WINDOW) {
+    logSecurityEvent({
+      type: 'rate_limit_exceeded',
+      timestamp: now,
+      details: `IP rate limit exceeded for ${ipAddress}: ${validTimestamps.length} requests in window`,
+      severity: 'high',
+      ipAddress,
+    });
+    return false;
+  }
+  
+  validTimestamps.push(now);
+  ipRateLimitTracker.set(ipAddress, validTimestamps);
+  return true;
+}
+
+function checkBlacklistWhitelist(phoneNumber: string): { valid: boolean; reason?: string } {
+  if (PHONE_BLACKLIST.has(phoneNumber)) {
+    logSecurityEvent({
+      type: 'blacklisted_phone',
+      timestamp: Date.now(),
+      details: `Phone number ${phoneNumber} is blacklisted`,
+      severity: 'high',
+    });
+    return { valid: false, reason: 'Phone number is blacklisted' };
+  }
+
+  if (WHITELIST_MODE_ENABLED && !PHONE_WHITELIST.has(phoneNumber)) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Phone number ${phoneNumber} is not whitelisted (whitelist mode enabled)`,
+      severity: 'medium',
+    });
+    return { valid: false, reason: 'Phone number is not whitelisted' };
+  }
+
+  return { valid: true };
+}
+
+function checkBlockedContent(message: string): { valid: boolean; reason?: string; matchedPattern?: string } {
+  for (const pattern of BLOCKED_CONTENT_PATTERNS) {
+    const match = message.match(pattern);
+    if (match) {
+      logSecurityEvent({
+        type: 'blocked_content',
+        timestamp: Date.now(),
+        details: `Message contains blocked content pattern: ${pattern.source}`,
+        severity: 'high',
+      });
+      return { valid: false, reason: 'Message contains blocked content', matchedPattern: pattern.source };
+    }
+  }
+  return { valid: true };
+}
+
+function checkCircuitBreaker(): boolean {
+  const now = Date.now();
+  
+  if (circuitBreakerState.isOpen) {
+    // Check if we should attempt to close the circuit breaker
+    if (now - circuitBreakerState.lastFailureTime > SECURITY_CONFIG.CIRCUIT_BREAKER_TIMEOUT_MS) {
+      circuitBreakerState.isOpen = false;
+      circuitBreakerState.failureCount = 0;
+      logSecurityEvent({
+        type: 'circuit_breaker_closed',
+        timestamp: now,
+        details: 'Circuit breaker closed after timeout',
+        severity: 'medium',
+      });
+      return true;
+    }
+    return false;
+  }
+  
+  return true;
+}
+
+function recordCircuitBreakerFailure(): void {
+  const now = Date.now();
+  circuitBreakerState.failureCount++;
+  circuitBreakerState.lastFailureTime = now;
+  
+  if (circuitBreakerState.failureCount >= SECURITY_CONFIG.CIRCUIT_BREAKER_THRESHOLD) {
+    circuitBreakerState.isOpen = true;
+    logSecurityEvent({
+      type: 'circuit_breaker_opened',
+      timestamp: now,
+      details: `Circuit breaker opened after ${circuitBreakerState.failureCount} failures`,
+      severity: 'critical',
+    });
+  }
+}
+
+function checkMessageDeduplication(to: string, message: string): boolean {
+  const now = Date.now();
+  const key = `${to}:${message}`;
+  const lastSent = messageDeduplicationTracker.get(key);
+  
+  if (lastSent && now - lastSent < SECURITY_CONFIG.DEDUPLICATION_WINDOW_MS) {
+    logSecurityEvent({
+      type: 'duplicate_message',
+      timestamp: now,
+      details: `Duplicate message detected for ${to} within deduplication window`,
+      severity: 'low',
+    });
+    return false;
+  }
+  
+  messageDeduplicationTracker.set(key, now);
+  
+  // Clean up old entries
+  for (const [k, t] of messageDeduplicationTracker.entries()) {
+    if (now - t > SECURITY_CONFIG.DEDUPLICATION_WINDOW_MS) {
+      messageDeduplicationTracker.delete(k);
+    }
+  }
+  
+  return true;
+}
+
+function sanitizeAndValidateSMS(to: string, message: string, ipAddress?: string): { valid: boolean; sanitized?: { to: string; message: string }; reason?: string } {
+  // Check circuit breaker first
+  if (!checkCircuitBreaker()) {
+    return { valid: false, reason: 'Circuit breaker is open, system is cooling down' };
+  }
+  
+  const phoneValidation = validatePhoneNumber(to);
+  if (!phoneValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Phone validation failed: ${phoneValidation.reason}`,
+      severity: 'medium',
+      ipAddress,
+    });
+    return { valid: false, reason: phoneValidation.reason };
+  }
+
+  const blacklistWhitelistCheck = checkBlacklistWhitelist(to);
+  if (!blacklistWhitelistCheck.valid) {
+    return { valid: false, reason: blacklistWhitelistCheck.reason };
+  }
+
+  const messageValidation = validateMessage(message);
+  if (!messageValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Message validation failed: ${messageValidation.reason}`,
+      severity: 'medium',
+      ipAddress,
+    });
+    return { valid: false, reason: messageValidation.reason };
+  }
+
+  const contentCheck = checkBlockedContent(message);
+  if (!contentCheck.valid) {
+    return { valid: false, reason: contentCheck.reason };
+  }
+
+  if (!checkRateLimit(to, ipAddress)) {
+    return { valid: false, reason: 'Rate limit exceeded' };
+  }
+
+  if (ipAddress && !checkIPRateLimit(ipAddress)) {
+    return { valid: false, reason: 'IP rate limit exceeded' };
+  }
+
+  if (!checkMessageDeduplication(to, message)) {
+    return { valid: false, reason: 'Duplicate message detected' };
+  }
+
+  // Sanitize message content
+  const sanitizedMessage = sanitizeString(message);
+
+  return {
+    valid: true,
+    sanitized: { to, message: sanitizedMessage },
+  };
+}
+
+// Seed queue for demonstration (with validation)
 for (let i = 0; i < 50; i++) {
-  smsQueue.enqueue(`+155512345${i.toString().padStart(2, '0')}`, `Test message ${i}`);
+  const phone = `+155512345${i.toString().padStart(2, '0')}`;
+  const message = `Test message ${i}`;
+  const validation = sanitizeAndValidateSMS(phone, message, '127.0.0.1');
+  if (validation.valid) {
+    smsQueue.enqueue(validation.sanitized!.to, validation.sanitized!.message);
+  }
 }
 
 export const startSMSClusterWorker = () => {
   if (cluster.isPrimary) {
-    logger.info(`Primary ${process.pid} is running`);
-    logger.info(`Setting up cluster with ${numCPUs} workers for SMS processing...`);
 
-    // Fork workers.
+
+    // Fork workers with resource limits
     for (let i = 0; i < numCPUs; i++) {
-      cluster.fork();
+      const worker = cluster.fork({
+        WORKER_ID: i,
+        NODE_OPTIONS: `--max-old-space-size=${SECURITY_CONFIG.WORKER_MAX_MEMORY_MB}`,
+      });
+
+      // Set worker timeout
+      setTimeout(() => {
+        if (worker.isConnected()) {
+          logSecurityEvent({
+            type: 'worker_timeout',
+            timestamp: Date.now(),
+            details: `Worker ${worker.process.pid} exceeded timeout, restarting`,
+            workerId: i,
+          });
+          worker.kill();
+        }
+      }, SECURITY_CONFIG.WORKER_TIMEOUT_MS);
     }
 
-    cluster.on('exit', (worker, code, signal) => {
-      logger.warn(`Worker ${worker.process.pid} died with code: ${code}, and signal: ${signal}`);
-      logger.info('Starting a new worker...');
+
       cluster.fork(); // Auto-heal workers
     });
+
+    // Periodic security audit log
+    setInterval(() => {
+      console.log(`[SECURITY AUDIT] Queue size: ${smsQueue.length}, Active workers: ${Object.keys(cluster.workers || {}).length}`);
+      console.log(`[SECURITY AUDIT] Total security events: ${securityEvents.length}`);
+      console.log(`[SECURITY AUDIT] Circuit breaker state: ${circuitBreakerState.isOpen ? 'OPEN' : 'CLOSED'}, Failures: ${circuitBreakerState.failureCount}`);
+      console.log(`[SECURITY AUDIT] Rate limit trackers: Phone numbers tracked: ${rateLimitTracker.size}, IPs tracked: ${ipRateLimitTracker.size}`);
+      console.log(`[SECURITY AUDIT] Deduplication tracker size: ${messageDeduplicationTracker.size}`);
+    }, 60000); // Every minute
   } else {
     // Workers can share any TCP connection
     // In this case it is an HTTP server or a message queue listener
-    logger.info(`Worker ${process.pid} started for SMS processing`);
+
 
     const processQueue = async () => {
-      // Basic mock of polling a queue
       const messageJob = smsQueue.dequeue();
       if (messageJob) {
+        const startTime = Date.now();
         try {
-          logger.debug(`[Worker ${process.pid}] Processing SMS for ${messageJob.to}...`);
-          // Note: In a real app we'd use sendSMS(messageJob.to, messageJob.message)
-          // For now we just mock the delay
-          await new Promise((resolve) => setTimeout(resolve, Math.random() * 500 + 100));
-          logger.info(`[Worker ${process.pid}] Successfully sent SMS to ${messageJob.to}`);
-        } catch (error) {
-          logger.error(`[Worker ${process.pid}] Failed to send SMS`, { error });
+
         }
       }
 
@@ -70,10 +424,125 @@ export const startSMSClusterWorker = () => {
       setTimeout(processQueue, 1000);
     };
 
+    // Worker health check
+    const performHealthCheck = () => {
+      const now = Date.now();
+      const healthState = workerHealthState.get(workerId) || { failures: 0, lastCheck: now };
+      
+      // Simulate health check (in real app, check actual worker metrics)
+      const isHealthy = process.memoryUsage().heapUsed < SECURITY_CONFIG.WORKER_MAX_MEMORY_MB * 1024 * 1024;
+      
+      if (!isHealthy) {
+        healthState.failures++;
+        logSecurityEvent({
+          type: 'health_check_failed',
+          timestamp: now,
+          details: `Worker ${workerId} health check failed. Failure count: ${healthState.failures}`,
+          workerId,
+          severity: healthState.failures >= SECURITY_CONFIG.MAX_HEALTH_CHECK_FAILURES ? 'critical' : 'medium',
+        });
+        
+        if (healthState.failures >= SECURITY_CONFIG.MAX_HEALTH_CHECK_FAILURES) {
+          console.error(`[Worker ${workerId}] Exceeded max health check failures, restarting...`);
+          process.exit(1);
+        }
+      } else {
+        healthState.failures = 0;
+      }
+      
+      healthState.lastCheck = now;
+      workerHealthState.set(workerId, healthState);
+    };
+    
+    setInterval(performHealthCheck, SECURITY_CONFIG.HEALTH_CHECK_INTERVAL_MS);
+
     processQueue();
   }
 };
 
+// Export security functions for external use
+export { sanitizeAndValidateSMS };
+
+export function getSecurityEvents(): SecurityEvent[] {
+  return [...securityEvents];
+}
+
+export function getQueueSize(): number {
+  return smsQueue.length;
+}
+
+export function getRateLimitStatus(phoneNumber: string): { remaining: number; resetTime: number } {
+  const now = Date.now();
+  const timestamps = rateLimitTracker.get(phoneNumber) || [];
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS);
+  const remaining = Math.max(0, SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW - validTimestamps.length);
+  const oldestTimestamp = validTimestamps.length > 0 ? Math.min(...validTimestamps) : now;
+  const resetTime = oldestTimestamp + SECURITY_CONFIG.RATE_LIMIT_WINDOW_MS;
+  
+  return { remaining, resetTime };
+}
+
+export function getIPRateLimitStatus(ipAddress: string): { remaining: number; resetTime: number } {
+  const now = Date.now();
+  const timestamps = ipRateLimitTracker.get(ipAddress) || [];
+  const validTimestamps = timestamps.filter(t => now - t < SECURITY_CONFIG.IP_RATE_LIMIT_WINDOW_MS);
+  const remaining = Math.max(0, SECURITY_CONFIG.IP_RATE_LIMIT_MAX_PER_WINDOW - validTimestamps.length);
+  const oldestTimestamp = validTimestamps.length > 0 ? Math.min(...validTimestamps) : now;
+  const resetTime = oldestTimestamp + SECURITY_CONFIG.IP_RATE_LIMIT_WINDOW_MS;
+  
+  return { remaining, resetTime };
+}
+
+export function getCircuitBreakerStatus(): { isOpen: boolean; failureCount: number; lastFailureTime: number } {
+  return {
+    isOpen: circuitBreakerState.isOpen,
+    failureCount: circuitBreakerState.failureCount,
+    lastFailureTime: circuitBreakerState.lastFailureTime,
+  };
+}
+
+export function addToPhoneBlacklist(phoneNumber: string): void {
+  PHONE_BLACKLIST.add(phoneNumber);
+  logSecurityEvent({
+    type: 'blacklisted_phone',
+    timestamp: Date.now(),
+    details: `Phone number ${phoneNumber} added to blacklist`,
+    severity: 'medium',
+  });
+}
+
+export function removeFromPhoneBlacklist(phoneNumber: string): void {
+  PHONE_BLACKLIST.delete(phoneNumber);
+}
+
+export function addToPhoneWhitelist(phoneNumber: string): void {
+  PHONE_WHITELIST.add(phoneNumber);
+}
+
+export function removeFromPhoneWhitelist(phoneNumber: string): void {
+  PHONE_WHITELIST.delete(phoneNumber);
+}
+
+export function setWhitelistMode(enabled: boolean): void {
+  WHITELIST_MODE_ENABLED = enabled;
+}
+
+export function addBlockedContentPattern(pattern: string): void {
+  BLOCKED_CONTENT_PATTERNS.push(new RegExp(pattern, 'gi'));
+}
+
+export function getWorkerHealthStatus(workerId: number): { isHealthy: boolean; failures: number; lastCheck: number } {
+  const healthState = workerHealthState.get(workerId);
+  if (!healthState) {
+    return { isHealthy: true, failures: 0, lastCheck: Date.now() };
+  }
+  return {
+    isHealthy: healthState.failures < SECURITY_CONFIG.MAX_HEALTH_CHECK_FAILURES,
+    failures: healthState.failures,
+    lastCheck: healthState.lastCheck,
+  };
+}
+
 // In a real entrypoint file, you'd call this:
 // if (require.main === module) {
 //   startSMSClusterWorker();