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..5219c4c5 100644
--- a/src/components/editor/ContentTemplateLibrary.tsx
+++ b/src/components/editor/ContentTemplateLibrary.tsx
@@ -15,47 +15,56 @@ 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"
-      >
+<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"
+  >
+    Content Templates
+  </h3>
+
+  {/* Sidebar content */}
+</aside>
         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..111f4e1c 100644
--- a/src/components/editor/MediaEmbedder.tsx
+++ b/src/components/editor/MediaEmbedder.tsx
@@ -1,4 +1,4 @@
-import React, { useId, useState } from 'react';
+import React, { useId, useState, useEffect, useRef } from 'react'; main
 import { Image as ImageIcon, Youtube as YoutubeIcon } from 'lucide-react';
 import { sanitizeUrl } from '@/utils/sanitize';
 
@@ -12,10 +12,68 @@ 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`;
+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;
+
+  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?.focus();
+  }
+}, [isOpen]);
 
   const handleSubmit = (e: React.FormEvent) => {
     e.preventDefault();
@@ -34,11 +92,21 @@ 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"
+<button
+  ref={triggerButtonRef}
+  type="button"
+  // other props...
+>main
           onClick={() => {
             setType('image');
             setIsOpen(true);
@@ -72,7 +140,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 +159,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 +173,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..c017fc53 100644
--- a/src/components/editor/RichContentEditor.tsx
+++ b/src/components/editor/RichContentEditor.tsx
@@ -1,5 +1,4 @@
-import React, { useId } from 'react';
-import { EditorContent } from '@tiptap/react';
+import React, { useEffect, useId, useRef, useState } from 'react'; EditorContent } from '@tiptap/react';
 import {
   Bold,
   Italic,
@@ -12,6 +11,7 @@ import {
   Redo,
   Heading1,
   Heading2,
+  Keyboard,
 } from 'lucide-react';
 import { useContentEditor } from '@/hooks/useContentEditor';
 import { MediaEmbedder } from './MediaEmbedder';
@@ -39,6 +39,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 +137,52 @@ 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}
+{/* Skip to editor link */}
+<a
+  href="#editor-content"
+  className="sr-only focus:not-sr-only focus:absolute focus:top-2 focus:left-2 focus:z-50 focus:bg-blue-600 focus:text-white focus:px-4 focus:py-2 focus:rounded"
+>
+  Skip to editor content
+</a>
+
+<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 +190,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 +205,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 +220,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 +235,32 @@ 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">
+<div
+  id={editorRegionId}
+  role="region"
+  aria-label="Post content editor"
+  tabIndex={-1}
+  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/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 c6c789dc..b3534d59 100644
--- a/src/workers/sms-cluster-worker.ts
+++ b/src/workers/sms-cluster-worker.ts
@@ -1,15 +1,60 @@
 import cluster from 'cluster';
 import os from 'os';
 import { sendSMS } from '../utils/notificationUtils'; // Assuming we have this or we'll mock it
+import { sanitizeString } from '../lib/security';
 
 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,
+  WORKER_MAX_MEMORY_MB: 512,
+  WORKER_TIMEOUT_MS: 30000,
+};
+
+// 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';
+  timestamp: number;
+  details: string;
+  workerId?: number;
+}
+
+const securityEvents: SecurityEvent[] = [];
+
+function logSecurityEvent(event: SecurityEvent) {
+  securityEvents.push(event);
+  console.error(`[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() {
@@ -23,43 +68,175 @@ 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): 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`,
+    });
+    return false;
+  }
+  
+  validTimestamps.push(now);
+  rateLimitTracker.set(phoneNumber, validTimestamps);
+  return true;
+}
+
+function sanitizeAndValidateSMS(to: string, message: string): { valid: boolean; sanitized?: { to: string; message: string }; reason?: string } {
+  const phoneValidation = validatePhoneNumber(to);
+  if (!phoneValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Phone validation failed: ${phoneValidation.reason}`,
+    });
+    return { valid: false, reason: phoneValidation.reason };
+  }
+
+  const messageValidation = validateMessage(message);
+  if (!messageValidation.valid) {
+    logSecurityEvent({
+      type: 'validation_failure',
+      timestamp: Date.now(),
+      details: `Message validation failed: ${messageValidation.reason}`,
+    });
+    return { valid: false, reason: messageValidation.reason };
+  }
+
+  if (!checkRateLimit(to)) {
+    return { valid: false, reason: 'Rate limit exceeded' };
+  }
+
+  // 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);
+  if (validation.valid) {
+    smsQueue.enqueue(validation.sanitized!.to, validation.sanitized!.message);
+  }
 }
 
 export const startSMSClusterWorker = () => {
   if (cluster.isPrimary) {
     console.log(`Primary ${process.pid} is running`);
     console.log(`Setting up cluster with ${numCPUs} workers for SMS processing...`);
+    console.log(`Security config: Max queue size=${SECURITY_CONFIG.MAX_QUEUE_SIZE}, Rate limit=${SECURITY_CONFIG.RATE_LIMIT_MAX_PER_WINDOW}/min`);
 
-    // 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) => {
       console.log(`Worker ${worker.process.pid} died with code: ${code}, and signal: ${signal}`);
+      logSecurityEvent({
+        type: 'worker_timeout',
+        timestamp: Date.now(),
+        details: `Worker ${worker.process.pid} exited unexpectedly. Code: ${code}, Signal: ${signal}`,
+      });
       console.log('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}`);
+    }, 60000); // Every minute
   } else {
     // Workers can share any TCP connection
     // In this case it is an HTTP server or a message queue listener
-    console.log(`Worker ${process.pid} started for SMS processing`);
+    const workerId = process.env.WORKER_ID ? parseInt(process.env.WORKER_ID) : process.pid;
+    console.log(`Worker ${process.pid} (ID: ${workerId}) started for SMS processing`);
 
     const processQueue = async () => {
-      // Basic mock of polling a queue
       const messageJob = smsQueue.dequeue();
       if (messageJob) {
+        const startTime = Date.now();
         try {
           console.log(`[Worker ${process.pid}] Processing SMS for ${messageJob.to}...`);
+          
+          // Validate before processing (double-check)
+          const validation = sanitizeAndValidateSMS(messageJob.to, messageJob.message);
+          if (!validation.valid) {
+            console.error(`[Worker ${process.pid}] Validation failed: ${validation.reason}`);
+            return;
+          }
+
           // 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));
-          console.log(`[Worker ${process.pid}] Successfully sent SMS to ${messageJob.to}`);
+          
+          const processingTime = Date.now() - startTime;
+          console.log(`[Worker ${process.pid}] Successfully sent SMS to ${messageJob.to} in ${processingTime}ms`);
         } catch (error) {
           console.error(`[Worker ${process.pid}] Failed to send SMS:`, error);
+          logSecurityEvent({
+            type: 'validation_failure',
+            timestamp: Date.now(),
+            details: `SMS processing failed for ${messageJob.to}: ${error}`,
+            workerId,
+          });
         }
       }
 
@@ -71,6 +248,28 @@ export const startSMSClusterWorker = () => {
   }
 };
 
+// Export security functions for external use
+export { sanitizeAndValidateSMS, getSecurityEvents };
+
+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 };
+}
+
 // In a real entrypoint file, you'd call this:
 // if (require.main === module) {
 //   startSMSClusterWorker();