diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 0000000..9e296ac
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(dir:*)",
+      "WebSearch",
+      "Bash(mkdir:*)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}
\ No newline at end of file
diff --git a/Dockerfile.base b/Dockerfile.base
index ade3d69..9684325 100644
--- a/Dockerfile.base
+++ b/Dockerfile.base
@@ -1,21 +1,123 @@
-# Base image with all ML dependencies
+# Base image with complete ML and hardware acceleration stack
 FROM pytorch/pytorch:2.8.0-cuda12.6-cudnn9-runtime
 
-# Install system dependencies
-RUN apt update && apt install -y \
-    libgl1 \
+# Install build dependencies and system libraries
+RUN apt-get update && apt-get install -y \
+    # Build tools
+    build-essential \
+    cmake \
+    git \
+    pkg-config \
+    wget \
+    unzip \
+    yasm \
+    nasm \
+    # Additional dependencies for FFmpeg/NVIDIA build
+    libtool \
+    libc6 \
+    libc6-dev \
+    libnuma1 \
+    libnuma-dev \
+    # Essential compilation libraries
+    gcc \
+    g++ \
+    libc6-dev \
+    linux-libc-dev \
+    # System libraries
+    libgl1-mesa-glx \
     libglib2.0-0 \
-    libgstreamer1.0-0 \
-    libgtk-3-0 \
-    libavcodec58 \
-    libavformat58 \
-    libswscale5 \
     libgomp1 \
+    # Core media libraries (essential ones only)
+    libjpeg-dev \
+    libpng-dev \
+    libx264-dev \
+    libx265-dev \
+    libvpx-dev \
+    libmp3lame-dev \
+    libv4l-dev \
+    # TurboJPEG for fast JPEG encoding
+    libturbojpeg0-dev \
+    # Python development
+    python3-dev \
+    python3-numpy \
     && rm -rf /var/lib/apt/lists/*
 
-# Copy and install base requirements (ML dependencies that rarely change)
+# Add NVIDIA CUDA repository and install minimal development tools
+RUN apt-get update && apt-get install -y wget gnupg && \
+    wget -O - https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/3bf863cc.pub | apt-key add - && \
+    echo "deb https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64 /" > /etc/apt/sources.list.d/cuda.list && \
+    apt-get update && \
+    apt-get install -y \
+    cuda-nvcc-12-6 \
+    cuda-cudart-dev-12-6 \
+    libnpp-dev-12-6 \
+    && apt-get remove -y wget gnupg && \
+    apt-get autoremove -y && \
+    rm -rf /var/lib/apt/lists/*
+
+# Ensure CUDA paths are available
+ENV PATH="/usr/local/cuda/bin:${PATH}"
+ENV LD_LIBRARY_PATH="/usr/local/cuda/lib64:${LD_LIBRARY_PATH}"
+
+# Install NVIDIA Video Codec SDK headers (official method)
+RUN cd /tmp && \
+    git clone https://git.videolan.org/git/ffmpeg/nv-codec-headers.git && \
+    cd nv-codec-headers && \
+    make install && \
+    cd / && rm -rf /tmp/*
+
+# Build FFmpeg from source with NVIDIA CUDA support
+RUN cd /tmp && \
+    echo "Building FFmpeg with NVIDIA CUDA support..." && \
+    # Download FFmpeg source (official method)
+    git clone https://git.ffmpeg.org/ffmpeg.git ffmpeg/ && \
+    cd ffmpeg && \
+    # Configure with NVIDIA support (simplified to avoid configure issues)
+    ./configure \
+        --prefix=/usr/local \
+        --enable-shared \
+        --disable-static \
+        --enable-nonfree \
+        --enable-gpl \
+        --enable-cuda-nvcc \
+        --enable-cuvid \
+        --enable-nvdec \
+        --enable-nvenc \
+        --enable-libnpp \
+        --extra-cflags=-I/usr/local/cuda/include \
+        --extra-ldflags=-L/usr/local/cuda/lib64 \
+        --enable-libx264 \
+        --enable-libx265 \
+        --enable-libvpx \
+        --enable-libmp3lame && \
+    # Build and install
+    make -j$(nproc) && \
+    make install && \
+    ldconfig && \
+    # Verify CUVID decoders are available
+    echo "=== Verifying FFmpeg CUVID Support ===" && \
+    (ffmpeg -hide_banner -decoders 2>/dev/null | grep cuvid || echo "No CUVID decoders found") && \
+    echo "=== Verifying FFmpeg NVENC Support ===" && \
+    (ffmpeg -hide_banner -encoders 2>/dev/null | grep nvenc || echo "No NVENC encoders found") && \
+    cd / && rm -rf /tmp/*
+
+# Set environment variables for maximum hardware acceleration
+ENV LD_LIBRARY_PATH="/usr/local/cuda/lib64:/usr/local/lib:${LD_LIBRARY_PATH}"
+ENV PKG_CONFIG_PATH="/usr/local/lib/pkgconfig:${PKG_CONFIG_PATH}"
+ENV PYTHONPATH="/usr/local/lib/python3.10/dist-packages:${PYTHONPATH}"
+
+# Optimized environment variables for hardware acceleration
+ENV OPENCV_FFMPEG_CAPTURE_OPTIONS="rtsp_transport;tcp|hwaccel;cuda|hwaccel_device;0|video_codec;h264_cuvid|hwaccel_output_format;cuda"
+ENV OPENCV_FFMPEG_WRITER_OPTIONS="video_codec;h264_nvenc|preset;fast|tune;zerolatency|gpu;0"
+ENV CUDA_VISIBLE_DEVICES=0
+ENV NVIDIA_VISIBLE_DEVICES=all
+ENV NVIDIA_DRIVER_CAPABILITIES=compute,video,utility
+
+# Copy and install base requirements (exclude opencv-python since we built from source)
 COPY requirements.base.txt .
-RUN pip install --no-cache-dir -r requirements.base.txt
+RUN grep -v opencv-python requirements.base.txt > requirements.tmp && \
+    mv requirements.tmp requirements.base.txt && \
+    pip install --no-cache-dir -r requirements.base.txt
 
 # Set working directory
 WORKDIR /app
diff --git a/IMPLEMENTATION_PLAN.md b/IMPLEMENTATION_PLAN.md
deleted file mode 100644
index 4836ad7..0000000
--- a/IMPLEMENTATION_PLAN.md
+++ /dev/null
@@ -1,339 +0,0 @@
-# Session-Isolated Multiprocessing Architecture - Implementation Plan
-
-## 🎯 Objective
-Eliminate shared state issues causing identical results across different sessions by implementing **Process-Per-Session architecture** with **per-camera logging**.
-
-## 🔍 Root Cause Analysis
-
-### Current Shared State Issues:
-1. **Shared Model Cache** (`core/models/inference.py:40`): All sessions share same cached YOLO model instances
-2. **Single Pipeline Instance** (`core/detection/pipeline.py`): One pipeline handles all sessions with shared mappings
-3. **Global Session Mappings**: `session_to_subscription` and `session_processing_results` dictionaries
-4. **Shared Thread Pool**: Single `ThreadPoolExecutor` for all sessions
-5. **Global Frame Cache** (`app.py:39`): `latest_frames` shared across endpoints
-6. **Single Log File**: All cameras write to `detector_worker.log`
-
-## 🏗️ New Architecture: Process-Per-Session
-
-```
-FastAPI Main Process (Port 8001)
-├── WebSocket Handler (manages connections)
-├── SessionProcessManager (spawns/manages session processes)
-├── Main Process Logger → detector_worker_main.log
-├──
-├── Session Process 1 (Camera/Display 1)
-│   ├── Dedicated Model Pipeline
-│   ├── Own Model Cache & Memory
-│   ├── Session Logger → detector_worker_camera_display-001_cam-001.log
-│   └── Redis/DB connections
-├──
-├── Session Process 2 (Camera/Display 2)
-│   ├── Dedicated Model Pipeline
-│   ├── Own Model Cache & Memory
-│   ├── Session Logger → detector_worker_camera_display-002_cam-001.log
-│   └── Redis/DB connections
-└──
-└── Session Process N...
-```
-
-## 📋 Implementation Tasks
-
-### Phase 1: Core Infrastructure ✅ **COMPLETED**
-- [x] **Create SessionProcessManager class** ✅
-  - Manages lifecycle of session processes
-  - Handles process spawning, monitoring, and cleanup
-  - Maintains process registry and health checks
-
-- [x] **Implement SessionWorkerProcess** ✅
-  - Individual process class that handles one session completely
-  - Loads own models, pipeline, and maintains state
-  - Communicates via queues with main process
-
-- [x] **Design Inter-Process Communication** ✅
-  - Command queue: Main → Session (frames, commands, config)
-  - Result queue: Session → Main (detections, status, errors)
-  - Use `multiprocessing.Queue` for thread-safe communication
-
-**Phase 1 Testing Results:**
-- ✅ Server starts successfully on port 8001
-- ✅ WebSocket connections established (10.100.1.3:57488)
-- ✅ SessionProcessManager initializes (max_sessions=20)
-- ✅ Multiple session processes created (9 camera subscriptions)
-- ✅ Individual session processes spawn with unique PIDs (e.g., PID: 16380)
-- ✅ Session logging shows isolated process names (SessionWorker-session_xxx)
-- ✅ IPC communication framework functioning
-
-**What to Look For When Testing:**
-- Check logs for "SessionProcessManager initialized"
-- Verify individual session processes: "Session process created: session_xxx (PID: xxxx)"
-- Monitor process isolation: Each session has unique process name "SessionWorker-session_xxx"
-- Confirm WebSocket integration: "Session WebSocket integration started"
-
-### Phase 2: Per-Session Logging ✅ **COMPLETED**
-- [x] **Implement PerSessionLogger** ✅
-  - Each session process creates own log file
-  - Format: `detector_worker_camera_{subscription_id}.log`
-  - Include session context in all log messages
-  - Implement log rotation (daily/size-based)
-
-- [x] **Update Main Process Logging** ✅
-  - Main process logs to `detector_worker_main.log`
-  - Log session process lifecycle events
-  - Track active sessions and resource usage
-
-**Phase 2 Testing Results:**
-- ✅ Main process logs to dedicated file: `logs/detector_worker_main.log`
-- ✅ Session-specific logger initialization working
-- ✅ Each camera spawns with unique session worker name: "SessionWorker-session_{unique_id}_{camera_name}"
-- ✅ Per-session logger ready for file creation (will create files when sessions fully initialize)
-- ✅ Structured logging with session context in format
-- ✅ Log rotation capability implemented (100MB max, 5 backups)
-
-**What to Look For When Testing:**
-- Check for main process log: `logs/detector_worker_main.log`
-- Monitor per-session process names in logs: "SessionWorker-session_xxx"
-- Once sessions initialize fully, look for per-camera log files: `detector_worker_camera_{camera_name}.log`
-- Verify session start/end events are logged with timestamps
-- Check log rotation when files exceed 100MB
-
-### Phase 3: Model & Pipeline Isolation ✅ **COMPLETED**
-- [x] **Remove Shared Model Cache** ✅
-  - Eliminated `YOLOWrapper._model_cache` class variable
-  - Each process loads models independently
-  - Memory isolation prevents cross-session contamination
-
-- [x] **Create Per-Process Pipeline Instances** ✅
-  - Each session process instantiates own `DetectionPipeline`
-  - Removed global pipeline singleton pattern
-  - Session-local `session_to_subscription` mapping
-
-- [x] **Isolate Session State** ✅
-  - Each process maintains own `session_processing_results`
-  - Session mappings are process-local
-  - Complete state isolation per session
-
-**Phase 3 Testing Results:**
-- ✅ **Zero Shared Cache**: Models log "(ISOLATED)" and "no shared cache!"
-- ✅ **Individual Model Loading**: Each session loads complete model set independently
-  - `car_frontal_detection_v1.pt` per session
-  - `car_brand_cls_v1.pt` per session
-  - `car_bodytype_cls_v1.pt` per session
-- ✅ **Pipeline Isolation**: Each session has unique pipeline instance ID
-- ✅ **Memory Isolation**: Different sessions cannot share model instances
-- ✅ **State Isolation**: Session mappings are process-local (ISOLATED comments added)
-
-**What to Look For When Testing:**
-- Check logs for "(ISOLATED)" on model loading
-- Verify each session loads models independently: "Loading YOLO model ... (ISOLATED)"
-- Monitor unique pipeline instance IDs per session
-- Confirm no shared state between sessions
-- Look for "Successfully loaded model ... in isolation - no shared cache!"
-
-### Phase 4: Integrated Stream-Session Architecture 🚧 **IN PROGRESS**
-
-**Problem Identified:** Frame processing pipeline not working due to dual stream systems causing communication gap.
-
-**Root Cause:**
-- Old RTSP Process Manager capturing frames but not forwarding to session workers
-- New Session Workers ready for processing but receiving no frames
-- Architecture mismatch preventing detection despite successful initialization
-
-**Solution:** Complete integration of stream reading INTO session worker processes.
-
-- [ ] **Integrate RTSP Stream Reading into Session Workers**
-  - Move RTSP stream capture from separate processes into each session worker
-  - Each session worker handles: RTSP connection + frame processing + model inference
-  - Eliminate communication gap between stream capture and detection
-
-- [ ] **Remove Duplicate Stream Management Systems**
-  - Delete old RTSP Process Manager (`core/streaming/process_manager.py`)
-  - Remove conflicting stream management from main process
-  - Consolidate to single session-worker-only architecture
-
-- [ ] **Enhanced Session Worker with Stream Integration**
-  - Add RTSP stream reader to `SessionWorkerProcess`
-  - Implement frame buffer queue management per worker
-  - Add connection recovery and stream health monitoring per session
-
-- [ ] **Complete End-to-End Isolation per Camera**
-  ```
-  Session Worker Process N:
-  ├── RTSP Stream Reader (rtsp://cameraN)
-  ├── Frame Buffer Queue
-  ├── YOLO Detection Pipeline
-  ├── Model Cache (isolated)
-  ├── Database/Redis connections
-  └── Per-camera Logger
-  ```
-
-**Benefits for 20+ Cameras:**
-- **Python GIL Bypass**: True parallelism with multiprocessing
-- **Resource Isolation**: Process crashes don't affect other cameras
-- **Memory Distribution**: Each process has own memory space
-- **Independent Recovery**: Per-camera reconnection logic
-- **Scalable Architecture**: Linear scaling with available CPU cores
-
-### Phase 5: Resource Management & Cleanup
-- [ ] **Process Lifecycle Management**
-  - Automatic process cleanup on WebSocket disconnect
-  - Graceful shutdown handling
-  - Resource deallocation on process termination
-
-- [ ] **Memory & GPU Management**
-  - Monitor per-process memory usage
-  - GPU memory isolation between sessions
-  - Prevent memory leaks in long-running processes
-
-- [ ] **Health Monitoring**
-  - Process health checks and restart capability
-  - Performance metrics per session process
-  - Resource usage monitoring and alerting
-
-## 🔄 What Will Be Replaced
-
-### Files to Modify:
-1. **`app.py`**
-   - Replace direct pipeline execution with process management
-   - Remove global `latest_frames` cache
-   - Add SessionProcessManager integration
-
-2. **`core/models/inference.py`**
-   - Remove shared `_model_cache` class variable
-   - Make model loading process-specific
-   - Eliminate cross-session model sharing
-
-3. **`core/detection/pipeline.py`**
-   - Remove global session mappings
-   - Make pipeline instance session-specific
-   - Isolate processing state per session
-
-4. **`core/communication/websocket.py`**
-   - Replace direct pipeline calls with IPC
-   - Add process spawn/cleanup on subscribe/unsubscribe
-   - Implement queue-based communication
-
-### New Files to Create:
-1. **`core/processes/session_manager.py`**
-   - SessionProcessManager class
-   - Process lifecycle management
-   - Health monitoring and cleanup
-
-2. **`core/processes/session_worker.py`**
-   - SessionWorkerProcess class
-   - Individual session process implementation
-   - Model loading and pipeline execution
-
-3. **`core/processes/communication.py`**
-   - IPC message definitions and handlers
-   - Queue management utilities
-   - Protocol for main ↔ session communication
-
-4. **`core/logging/session_logger.py`**
-   - Per-session logging configuration
-   - Log file management and rotation
-   - Structured logging with session context
-
-## ❌ What Will Be Removed
-
-### Code to Remove:
-1. **Shared State Variables**
-   ```python
-   # From core/models/inference.py
-   _model_cache: Dict[str, Any] = {}
-
-   # From core/detection/pipeline.py
-   self.session_to_subscription = {}
-   self.session_processing_results = {}
-
-   # From app.py
-   latest_frames = {}
-   ```
-
-2. **Global Singleton Patterns**
-   - Single pipeline instance handling all sessions
-   - Shared ThreadPoolExecutor across sessions
-   - Global model manager for all subscriptions
-
-3. **Cross-Session Dependencies**
-   - Session mapping lookups across different subscriptions
-   - Shared processing state between unrelated sessions
-   - Global frame caching across all cameras
-
-## 🔧 Configuration Changes
-
-### New Configuration Options:
-```json
-{
-  "session_processes": {
-    "max_concurrent_sessions": 20,
-    "process_cleanup_timeout": 30,
-    "health_check_interval": 10,
-    "log_rotation": {
-      "max_size_mb": 100,
-      "backup_count": 5
-    }
-  },
-  "resource_limits": {
-    "memory_per_process_mb": 2048,
-    "gpu_memory_fraction": 0.3
-  }
-}
-```
-
-## 📊 Benefits of New Architecture
-
-### 🛡️ Complete Isolation:
-- **Memory Isolation**: Each session runs in separate process memory space
-- **Model Isolation**: No shared model cache between sessions
-- **State Isolation**: Session mappings and processing state are process-local
-- **Error Isolation**: Process crashes don't affect other sessions
-
-### 📈 Performance Improvements:
-- **True Parallelism**: Bypass Python GIL limitations
-- **Resource Optimization**: Each process uses only required resources
-- **Scalability**: Linear scaling with available CPU cores
-- **Memory Efficiency**: Automatic cleanup on session termination
-
-### 🔍 Enhanced Monitoring:
-- **Per-Camera Logs**: Dedicated log file for each session
-- **Resource Tracking**: Monitor CPU/memory per session process
-- **Debugging**: Isolated logs make issue diagnosis easier
-- **Audit Trail**: Complete processing history per camera
-
-### 🚀 Operational Benefits:
-- **Zero Cross-Session Contamination**: Impossible for sessions to affect each other
-- **Hot Restart**: Individual session restart without affecting others
-- **Resource Control**: Fine-grained resource allocation per session
-- **Development**: Easier testing and debugging of individual sessions
-
-## 🎬 Implementation Order
-
-1. **Phase 1**: Core infrastructure (SessionProcessManager, IPC)
-2. **Phase 2**: Per-session logging system
-3. **Phase 3**: Model and pipeline isolation
-4. **Phase 4**: Resource management and monitoring
-
-## 🧪 Testing Strategy
-
-1. **Unit Tests**: Test individual session processes in isolation
-2. **Integration Tests**: Test main ↔ session process communication
-3. **Load Tests**: Multiple concurrent sessions with different models
-4. **Memory Tests**: Verify no cross-session memory leaks
-5. **Logging Tests**: Verify correct log file creation and rotation
-
-## 📝 Migration Checklist
-
-- [ ] Backup current working version
-- [ ] Implement Phase 1 (core infrastructure)
-- [ ] Test with single session process
-- [ ] Implement Phase 2 (logging)
-- [ ] Test with multiple concurrent sessions
-- [ ] Implement Phase 3 (isolation)
-- [ ] Verify complete elimination of shared state
-- [ ] Implement Phase 4 (resource management)
-- [ ] Performance testing and optimization
-- [ ] Documentation updates
-
----
-
-**Expected Outcome**: Complete elimination of cross-session result contamination with enhanced monitoring capabilities and true session isolation.
\ No newline at end of file
diff --git a/RTSP_SCALING_SOLUTION.md b/RTSP_SCALING_SOLUTION.md
deleted file mode 100644
index 6162090..0000000
--- a/RTSP_SCALING_SOLUTION.md
+++ /dev/null
@@ -1,411 +0,0 @@
-# RTSP Stream Scaling Solution Plan
-
-## Problem Statement
-Current implementation fails with 8+ concurrent RTSP streams (1280x720@6fps) due to:
-- Python GIL bottleneck limiting true parallelism
-- OpenCV/FFMPEG resource contention
-- Thread starvation causing frame read failures
-- Socket buffer exhaustion dropping UDP packets
-
-## Selected Solution: Phased Approach
-
-### Phase 1: Quick Fix - Multiprocessing (8-20 cameras)
-**Timeline:** 1-2 days
-**Goal:** Immediate fix for current 8 camera deployment
-
-### Phase 2: Long-term - go2rtc or GStreamer/FFmpeg Proxy (20+ cameras)
-**Timeline:** 1-2 weeks
-**Goal:** Scalable architecture for future growth
-
----
-
-## Implementation Checklist
-
-### Phase 1: Multiprocessing Solution
-
-#### Core Architecture Changes
-- [x] Create `RTSPProcessManager` class to manage camera processes
-- [x] Implement shared memory for frame passing (using `multiprocessing.shared_memory`)
-- [x] Create `CameraProcess` worker class for individual camera handling
-- [x] Add process pool executor with configurable worker count
-- [x] Implement process health monitoring and auto-restart
-
-#### Frame Pipeline
-- [x] Replace threading.Thread with multiprocessing.Process for readers
-- [x] Implement zero-copy frame transfer using shared memory buffers
-- [x] Add frame queue with backpressure handling
-- [x] Create frame skipping logic when processing falls behind
-- [x] Add timestamp-based frame dropping (keep only recent frames)
-
-#### Thread Safety & Synchronization (CRITICAL)
-- [x] Implement `multiprocessing.Lock()` for all shared memory write operations
-- [x] Use `multiprocessing.Queue()` instead of shared lists (thread-safe by design)
-- [x] Replace counters with `multiprocessing.Value()` for atomic operations
-- [x] Implement lock-free ring buffer using `multiprocessing.Array()` for frames
-- [x] Use `multiprocessing.Manager()` for complex shared objects (dicts, lists)
-- [x] Add memory barriers for CPU cache coherency
-- [x] Create read-write locks for frame buffers (multiple readers, single writer)
-- [ ] Implement semaphores for limiting concurrent RTSP connections
-- [ ] Add process-safe logging with `QueueHandler` and `QueueListener`
-- [ ] Use `multiprocessing.Condition()` for frame-ready notifications
-- [ ] Implement deadlock detection and recovery mechanism
-- [x] Add timeout on all lock acquisitions to prevent hanging
-- [ ] Create lock hierarchy documentation to prevent deadlocks
-- [ ] Implement lock-free data structures where possible (SPSC queues)
-- [x] Add memory fencing for shared memory access patterns
-
-#### Resource Management
-- [ ] Set process CPU affinity for better cache utilization
-- [x] Implement memory pool for frame buffers (prevent allocation overhead)
-- [x] Add configurable process limits based on CPU cores
-- [x] Create graceful shutdown mechanism for all processes
-- [x] Add resource monitoring (CPU, memory per process)
-
-#### Configuration Updates
-- [x] Add `max_processes` config parameter (default: CPU cores - 2)
-- [x] Add `frames_per_second_limit` for frame skipping
-- [x] Add `frame_queue_size` parameter
-- [x] Add `process_restart_threshold` for failure recovery
-- [x] Update Docker container to handle multiprocessing
-
-#### Error Handling
-- [x] Implement process crash detection and recovery
-- [x] Add exponential backoff for process restarts
-- [x] Create dead process cleanup mechanism
-- [x] Add logging aggregation from multiple processes
-- [x] Implement shared error counter with thresholds
-- [x] Fix uvicorn multiprocessing bootstrap compatibility
-- [x] Add lazy initialization for multiprocessing manager
-- [x] Implement proper fallback chain (multiprocessing → threading)
-
-#### Testing
-- [x] Test with 8 cameras simultaneously
-- [x] Verify frame rate stability under load
-- [x] Test process crash recovery
-- [x] Measure CPU and memory usage
-- [ ] Load test with 15-20 cameras
-
----
-
-### Phase 2: go2rtc or GStreamer/FFmpeg Proxy Solution
-
-#### Option A: go2rtc Integration (Recommended)
-- [ ] Deploy go2rtc as separate service container
-- [ ] Configure go2rtc streams.yaml for all cameras
-- [ ] Implement Python client to consume go2rtc WebRTC/HLS streams
-- [ ] Add automatic camera discovery and registration
-- [ ] Create health monitoring for go2rtc service
-
-#### Option B: Custom Proxy Service
-- [ ] Create standalone RTSP proxy service
-- [ ] Implement GStreamer pipeline for multiple RTSP inputs
-- [ ] Add hardware acceleration detection (NVDEC, VAAPI)
-- [ ] Create shared memory or socket output for frames
-- [ ] Implement dynamic stream addition/removal API
-
-#### Integration Layer
-- [ ] Create Python client for proxy service
-- [ ] Implement frame receiver from proxy
-- [ ] Add stream control commands (start/stop/restart)
-- [ ] Create fallback to multiprocessing if proxy fails
-- [ ] Add proxy health monitoring
-
-#### Performance Optimization
-- [ ] Implement hardware decoder auto-detection
-- [ ] Add adaptive bitrate handling
-- [ ] Create intelligent frame dropping at source
-- [ ] Add network buffer tuning
-- [ ] Implement zero-copy frame pipeline
-
-#### Deployment
-- [ ] Create Docker container for proxy service
-- [ ] Add Kubernetes deployment configs
-- [ ] Create service mesh for multi-instance scaling
-- [ ] Add load balancer for camera distribution
-- [ ] Implement monitoring and alerting
-
----
-
-## Quick Wins (Implement Immediately)
-
-### Network Optimizations
-- [ ] Increase system socket buffer sizes:
-  ```bash
-  sysctl -w net.core.rmem_default=2097152
-  sysctl -w net.core.rmem_max=8388608
-  ```
-- [ ] Increase file descriptor limits:
-  ```bash
-  ulimit -n 65535
-  ```
-- [ ] Add to Docker compose:
-  ```yaml
-  ulimits:
-    nofile:
-      soft: 65535
-      hard: 65535
-  ```
-
-### Code Optimizations
-- [ ] Fix RTSP TCP transport bug in readers.py
-- [ ] Increase error threshold to 30 (already done)
-- [ ] Add frame timestamp checking to skip old frames
-- [ ] Implement connection pooling for RTSP streams
-- [ ] Add configurable frame skip interval
-
-### Monitoring
-- [ ] Add metrics for frames processed/dropped per camera
-- [ ] Log queue sizes and processing delays
-- [ ] Track FFMPEG/OpenCV resource usage
-- [ ] Create dashboard for stream health monitoring
-
----
-
-## Performance Targets
-
-### Phase 1 (Multiprocessing)
-- Support: 15-20 cameras
-- Frame rate: Stable 5-6 fps per camera
-- CPU usage: < 80% on 8-core system
-- Memory: < 2GB total
-- Latency: < 200ms frame-to-detection
-
-### Phase 2 (GStreamer)
-- Support: 50+ cameras (100+ with HW acceleration)
-- Frame rate: Full 6 fps per camera
-- CPU usage: < 50% on 8-core system
-- Memory: < 1GB for proxy + workers
-- Latency: < 100ms frame-to-detection
-
----
-
-## Risk Mitigation
-
-### Known Risks
-1. **Race Conditions** - Multiple processes writing to same memory location
-   - *Mitigation*: Strict locking protocol, atomic operations only
-2. **Deadlocks** - Circular lock dependencies between processes
-   - *Mitigation*: Lock ordering, timeouts, deadlock detection
-3. **Frame Corruption** - Partial writes to shared memory during reads
-   - *Mitigation*: Double buffering, memory barriers, atomic swaps
-4. **Memory Coherency** - CPU cache inconsistencies between cores
-   - *Mitigation*: Memory fencing, volatile markers, cache line padding
-5. **Lock Contention** - Too many processes waiting for same lock
-   - *Mitigation*: Fine-grained locks, lock-free structures, sharding
-6. **Multiprocessing overhead** - Monitor shared memory performance
-7. **Memory leaks** - Implement proper cleanup and monitoring
-8. **Network bandwidth** - Add bandwidth monitoring and alerts
-9. **Hardware limitations** - Profile and set realistic limits
-
-### Fallback Strategy
-- Keep current threading implementation as fallback
-- Implement feature flag to switch between implementations
-- Add automatic fallback on repeated failures
-- Maintain backwards compatibility with existing API
-
----
-
-## Success Criteria
-
-### Phase 1 Complete When:
-- [x] All 8 cameras run simultaneously without frame read failures ✅ COMPLETED
-- [x] System stable for 24+ hours continuous operation ✅ VERIFIED IN PRODUCTION
-- [x] CPU usage remains below 80% (distributed across processes) ✅ MULTIPROCESSING ACTIVE
-- [x] No memory leaks detected ✅ PROCESS ISOLATION PREVENTS LEAKS
-- [x] Frame processing latency < 200ms ✅ BYPASSES GIL BOTTLENECK
-
-**PHASE 1 IMPLEMENTATION: ✅ COMPLETED 2025-09-25**
-
-### Phase 2 Complete When:
-- [ ] Successfully handling 20+ cameras
-- [ ] Hardware acceleration working (if available)
-- [ ] Proxy service stable and monitored
-- [ ] Automatic scaling implemented
-- [ ] Full production deployment complete
-
----
-
-## Thread Safety Implementation Details
-
-### Critical Sections Requiring Synchronization
-
-#### 1. Frame Buffer Access
-```python
-# UNSAFE - Race condition
-shared_frames[camera_id] = new_frame  # Multiple writers
-
-# SAFE - With proper locking
-with frame_locks[camera_id]:
-    # Double buffer swap to avoid corruption
-    write_buffer = frame_buffers[camera_id]['write']
-    write_buffer[:] = new_frame
-    # Atomic swap of buffer pointers
-    frame_buffers[camera_id]['write'], frame_buffers[camera_id]['read'] = \
-        frame_buffers[camera_id]['read'], frame_buffers[camera_id]['write']
-```
-
-#### 2. Statistics/Counters
-```python
-# UNSAFE
-frame_count += 1  # Not atomic
-
-# SAFE
-with frame_count.get_lock():
-    frame_count.value += 1
-# OR use atomic Value
-frame_count = multiprocessing.Value('i', 0)  # Atomic integer
-```
-
-#### 3. Queue Operations
-```python
-# SAFE - multiprocessing.Queue is thread-safe
-frame_queue = multiprocessing.Queue(maxsize=100)
-# Put with timeout to avoid blocking
-try:
-    frame_queue.put(frame, timeout=0.1)
-except queue.Full:
-    # Handle backpressure
-    pass
-```
-
-#### 4. Shared Memory Layout
-```python
-# Define memory structure with proper alignment
-class FrameBuffer:
-    def __init__(self, camera_id, width=1280, height=720):
-        # Align to cache line boundary (64 bytes)
-        self.lock = multiprocessing.Lock()
-
-        # Double buffering for lock-free reads
-        buffer_size = width * height * 3  # RGB
-        self.buffer_a = multiprocessing.Array('B', buffer_size)
-        self.buffer_b = multiprocessing.Array('B', buffer_size)
-
-        # Atomic pointer to current read buffer (0 or 1)
-        self.read_buffer_idx = multiprocessing.Value('i', 0)
-
-        # Metadata (atomic access)
-        self.timestamp = multiprocessing.Value('d', 0.0)
-        self.frame_number = multiprocessing.Value('L', 0)
-```
-
-### Lock-Free Patterns
-
-#### Single Producer, Single Consumer (SPSC) Queue
-```python
-# Lock-free for one writer, one reader
-class SPSCQueue:
-    def __init__(self, size):
-        self.buffer = multiprocessing.Array('i', size)
-        self.head = multiprocessing.Value('L', 0)  # Writer position
-        self.tail = multiprocessing.Value('L', 0)  # Reader position
-        self.size = size
-
-    def put(self, item):
-        next_head = (self.head.value + 1) % self.size
-        if next_head == self.tail.value:
-            return False  # Queue full
-        self.buffer[self.head.value] = item
-        self.head.value = next_head  # Atomic update
-        return True
-```
-
-### Memory Barrier Considerations
-```python
-import ctypes
-
-# Ensure memory visibility across CPU cores
-def memory_fence():
-    # Force CPU cache synchronization
-    ctypes.CDLL(None).sched_yield()  # Linux/Unix
-    # OR use threading.Barrier for synchronization points
-```
-
-### Deadlock Prevention Strategy
-
-#### Lock Ordering Protocol
-```python
-# Define strict lock acquisition order
-LOCK_ORDER = {
-    'frame_buffer': 1,
-    'statistics': 2,
-    'queue': 3,
-    'config': 4
-}
-
-# Always acquire locks in ascending order
-def safe_multi_lock(locks):
-    sorted_locks = sorted(locks, key=lambda x: LOCK_ORDER[x.name])
-    for lock in sorted_locks:
-        lock.acquire(timeout=5.0)  # Timeout prevents hanging
-```
-
-#### Monitoring & Detection
-```python
-# Deadlock detector
-def detect_deadlocks():
-    import threading
-    for thread in threading.enumerate():
-        if thread.is_alive():
-            frame = sys._current_frames().get(thread.ident)
-            if frame and 'acquire' in str(frame):
-                logger.warning(f"Potential deadlock: {thread.name}")
-```
-
----
-
-## Notes
-
-### Current Bottlenecks (Must Address)
-- Python GIL preventing parallel frame reading
-- FFMPEG internal buffer management
-- Thread context switching overhead
-- Socket receive buffer too small for 8 streams
-- **Thread safety in shared memory access** (CRITICAL)
-
-### Key Insights
-- Don't need every frame - intelligent dropping is acceptable
-- Hardware acceleration is crucial for 50+ cameras
-- Process isolation prevents cascade failures
-- Shared memory faster than queues for large frames
-
-### Dependencies to Add
-```txt
-# requirements.txt additions
-psutil>=5.9.0  # Process monitoring
-py-cpuinfo>=9.0.0  # CPU detection
-shared-memory-dict>=0.7.2  # Shared memory utils
-multiprocess>=0.70.14  # Better multiprocessing with dill
-atomicwrites>=1.4.0  # Atomic file operations
-portalocker>=2.7.0  # Cross-platform file locking
-```
-
----
-
-**Last Updated:** 2025-09-25 (Updated with uvicorn compatibility fixes)
-**Priority:** ✅ COMPLETED - Phase 1 deployed and working in production
-**Owner:** Engineering Team
-
-## 🎉 IMPLEMENTATION STATUS: PHASE 1 COMPLETED
-
-**✅ SUCCESS**: The multiprocessing solution has been successfully implemented and is now handling 8 concurrent RTSP streams without frame read failures.
-
-### What Was Fixed:
-1. **Root Cause**: Python GIL bottleneck limiting concurrent RTSP stream processing
-2. **Solution**: Complete multiprocessing architecture with process isolation
-3. **Key Components**: RTSPProcessManager, SharedFrameBuffer, process monitoring
-4. **Critical Fix**: Uvicorn compatibility through proper multiprocessing context initialization
-5. **Architecture**: Lazy initialization pattern prevents bootstrap timing issues
-6. **Fallback**: Intelligent fallback to threading if multiprocessing fails (proper redundancy)
-
-### Current Status:
-- ✅ All 8 cameras running in separate processes (PIDs: 14799, 14802, 14805, 14810, 14813, 14816, 14820, 14823)
-- ✅ No frame read failures observed
-- ✅ CPU load distributed across multiple cores
-- ✅ Memory isolation per process prevents cascade failures
-- ✅ Multiprocessing initialization fixed for uvicorn compatibility
-- ✅ Lazy initialization prevents bootstrap timing issues
-- ✅ Threading fallback maintained for edge cases (proper architecture)
-
-### Next Steps:
-Phase 2 planning for 20+ cameras using go2rtc or GStreamer proxy.
\ No newline at end of file
diff --git a/app.py b/app.py
index c4b5509..21d89db 100644
--- a/app.py
+++ b/app.py
@@ -4,35 +4,109 @@ Refactored modular architecture for computer vision pipeline processing.
 """
 import json
 import logging
-import multiprocessing as mp
 import os
 import time
+import cv2
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, WebSocket, HTTPException, Request
+from typing import Dict, Any
+from fastapi import FastAPI, WebSocket, HTTPException
 from fastapi.responses import Response
 
-# Set multiprocessing start method to 'spawn' for uvicorn compatibility
-if __name__ != "__main__":  # When imported by uvicorn
-    try:
-        mp.set_start_method('spawn', force=True)
-    except RuntimeError:
-        pass  # Already set
-
 # Import new modular communication system
 from core.communication.websocket import websocket_endpoint
 from core.communication.state import worker_state
 
-# Import and setup main process logging
-from core.logging.session_logger import setup_main_process_logging
-
-# Configure main process logging
-setup_main_process_logging("logs")
+# Configure logging
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[
+        logging.FileHandler("detector_worker.log"),
+        logging.StreamHandler()
+    ]
+)
 
 logger = logging.getLogger("detector_worker")
 logger.setLevel(logging.DEBUG)
 
-# Store cached frames for REST API access (temporary storage)
-latest_frames = {}
+# Frames are now stored in the shared cache buffer from core.streaming.buffers
+# latest_frames = {}  # Deprecated - using shared_cache_buffer instead
+
+
+# Health monitoring recovery handlers
+def _handle_stream_restart_recovery(component: str, details: Dict[str, Any]) -> bool:
+    """Handle stream restart recovery at the application level."""
+    try:
+        from core.streaming.manager import shared_stream_manager
+
+        # Extract camera ID from component name (e.g., "stream_cam-001" -> "cam-001")
+        if component.startswith("stream_"):
+            camera_id = component[7:]  # Remove "stream_" prefix
+        else:
+            camera_id = component
+
+        logger.info(f"Attempting stream restart recovery for {camera_id}")
+
+        # Find and restart the subscription
+        subscriptions = shared_stream_manager.get_all_subscriptions()
+        for sub_info in subscriptions:
+            if sub_info.camera_id == camera_id:
+                # Remove and re-add the subscription
+                shared_stream_manager.remove_subscription(sub_info.subscription_id)
+                time.sleep(1.0)  # Brief delay
+
+                # Re-add subscription
+                success = shared_stream_manager.add_subscription(
+                    sub_info.subscription_id,
+                    sub_info.stream_config,
+                    sub_info.crop_coords,
+                    sub_info.model_id,
+                    sub_info.model_url,
+                    sub_info.tracking_integration
+                )
+
+                if success:
+                    logger.info(f"Stream restart recovery successful for {camera_id}")
+                    return True
+                else:
+                    logger.error(f"Stream restart recovery failed for {camera_id}")
+                    return False
+
+        logger.warning(f"No subscription found for camera {camera_id} during recovery")
+        return False
+
+    except Exception as e:
+        logger.error(f"Error in stream restart recovery for {component}: {e}")
+        return False
+
+
+def _handle_stream_reconnect_recovery(component: str, details: Dict[str, Any]) -> bool:
+    """Handle stream reconnect recovery at the application level."""
+    try:
+        from core.streaming.manager import shared_stream_manager
+
+        # Extract camera ID from component name
+        if component.startswith("stream_"):
+            camera_id = component[7:]
+        else:
+            camera_id = component
+
+        logger.info(f"Attempting stream reconnect recovery for {camera_id}")
+
+        # For reconnect, we just need to trigger the stream's internal reconnect
+        # The stream readers handle their own reconnection logic
+        active_cameras = shared_stream_manager.get_active_cameras()
+
+        if camera_id in active_cameras:
+            logger.info(f"Stream reconnect recovery triggered for {camera_id}")
+            return True
+        else:
+            logger.warning(f"Camera {camera_id} not found in active cameras during reconnect recovery")
+            return False
+
+    except Exception as e:
+        logger.error(f"Error in stream reconnect recovery for {component}: {e}")
+        return False
 
 # Lifespan event handler (modern FastAPI approach)
 @asynccontextmanager
@@ -40,20 +114,58 @@ async def lifespan(app: FastAPI):
     """Application lifespan management."""
     # Startup
     logger.info("Detector Worker started successfully")
+
+    # Initialize health monitoring system
+    try:
+        from core.monitoring.health import health_monitor
+        from core.monitoring.stream_health import stream_health_tracker
+        from core.monitoring.thread_health import thread_health_monitor
+        from core.monitoring.recovery import recovery_manager
+
+        # Start health monitoring
+        health_monitor.start()
+        logger.info("Health monitoring system started")
+
+        # Register recovery handlers for stream management
+        from core.streaming.manager import shared_stream_manager
+        recovery_manager.register_recovery_handler(
+            "restart_stream",
+            _handle_stream_restart_recovery
+        )
+        recovery_manager.register_recovery_handler(
+            "reconnect",
+            _handle_stream_reconnect_recovery
+        )
+
+        logger.info("Recovery handlers registered")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize health monitoring: {e}")
+
     logger.info("WebSocket endpoint available at: ws://0.0.0.0:8001/")
     logger.info("HTTP camera endpoint available at: http://0.0.0.0:8001/camera/{camera_id}/image")
     logger.info("Health check available at: http://0.0.0.0:8001/health")
+    logger.info("Detailed health monitoring available at: http://0.0.0.0:8001/health/detailed")
     logger.info("Ready and waiting for backend WebSocket connections")
 
     yield
 
     # Shutdown
     logger.info("Detector Worker shutting down...")
+
+    # Stop health monitoring
+    try:
+        from core.monitoring.health import health_monitor
+        health_monitor.stop()
+        logger.info("Health monitoring system stopped")
+    except Exception as e:
+        logger.error(f"Error stopping health monitoring: {e}")
+
     # Clear all state
     worker_state.set_subscriptions([])
     worker_state.session_ids.clear()
     worker_state.progression_stages.clear()
-    latest_frames.clear()
+    # latest_frames.clear()  # No longer needed - frames are in shared_cache_buffer
     logger.info("Detector Worker shutdown complete")
 
 # Create FastAPI application with detailed WebSocket logging
@@ -89,12 +201,14 @@ else:
 os.makedirs("models", exist_ok=True)
 logger.info("Ensured models directory exists")
 
-# Stream manager is already initialized with multiprocessing in manager.py
-# (shared_stream_manager is created with max_streams=20 from config)
-logger.info(f"Using pre-configured stream manager with max_streams={config.get('max_streams', 20)}")
+# Stream manager already initialized at module level with max_streams=20
+# Calling initialize_stream_manager() creates a NEW instance, breaking references
+# from core.streaming import initialize_stream_manager
+# initialize_stream_manager(max_streams=config.get('max_streams', 10))
+logger.info(f"Using stream manager with max_streams=20 (module-level initialization)")
 
-# Store cached frames for REST API access (temporary storage)
-latest_frames = {}
+# Frames are now stored in the shared cache buffer from core.streaming.buffers
+# latest_frames = {}  # Deprecated - using shared_cache_buffer instead
 
 logger.info("Starting detector worker application (refactored)")
 logger.info(f"Configuration: Target FPS: {config.get('target_fps', 10)}, "
@@ -153,31 +267,33 @@ async def get_camera_image(camera_id: str):
                 detail=f"Camera {camera_id} not found or not active"
             )
 
-        # Check if we have a cached frame for this camera
-        if camera_id not in latest_frames:
-            logger.warning(f"No cached frame available for camera '{camera_id}'")
+        # Extract actual camera_id from subscription identifier (displayId;cameraId)
+        # Frames are stored using just the camera_id part
+        actual_camera_id = camera_id.split(';')[-1] if ';' in camera_id else camera_id
+
+        # Get frame from the shared cache buffer
+        from core.streaming.buffers import shared_cache_buffer
+
+        # Only show buffer debug info if camera not found (to reduce log spam)
+        available_cameras = shared_cache_buffer.frame_buffer.get_camera_list()
+
+        frame = shared_cache_buffer.get_frame(actual_camera_id)
+        if frame is None:
+            logger.warning(f"\033[93m[API] No frame for '{actual_camera_id}' - Available: {available_cameras}\033[0m")
             raise HTTPException(
                 status_code=404,
-                detail=f"No frame available for camera {camera_id}"
+                detail=f"No frame available for camera {actual_camera_id}"
             )
 
-        frame = latest_frames[camera_id]
-        logger.debug(f"Retrieved cached frame for camera '{camera_id}', shape: {frame.shape}")
+        # Successful frame retrieval - log only occasionally to avoid spam
 
-        # TODO: This import will be replaced in Phase 3 (Streaming System)
-        # For now, we need to handle the case where OpenCV is not available
-        try:
-            import cv2
-            # Encode frame as JPEG
-            success, buffer_img = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
-            if not success:
-                raise HTTPException(status_code=500, detail="Failed to encode image as JPEG")
+        # Encode frame as JPEG
+        success, buffer_img = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to encode image as JPEG")
 
-            # Return image as binary response
-            return Response(content=buffer_img.tobytes(), media_type="image/jpeg")
-        except ImportError:
-            logger.error("OpenCV not available for image encoding")
-            raise HTTPException(status_code=500, detail="Image processing not available")
+        # Return image as binary response
+        return Response(content=buffer_img.tobytes(), media_type="image/jpeg")
 
     except HTTPException:
         raise
@@ -186,6 +302,63 @@ async def get_camera_image(camera_id: str):
         raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
 
+@app.get("/session-image/{session_id}")
+async def get_session_image(session_id: int):
+    """
+    HTTP endpoint to retrieve the saved session image by session ID.
+
+    Args:
+        session_id: The session ID to retrieve the image for
+
+    Returns:
+        JPEG image as binary response
+
+    Raises:
+        HTTPException: 404 if no image found for the session
+        HTTPException: 500 if reading image fails
+    """
+    try:
+        from pathlib import Path
+        import glob
+
+        # Images directory
+        images_dir = Path("images")
+
+        if not images_dir.exists():
+            logger.warning(f"Images directory does not exist")
+            raise HTTPException(
+                status_code=404,
+                detail=f"No images directory found"
+            )
+
+        # Search for files matching session ID pattern: {session_id}_*
+        pattern = str(images_dir / f"{session_id}_*.jpg")
+        matching_files = glob.glob(pattern)
+
+        if not matching_files:
+            logger.warning(f"No image found for session {session_id}")
+            raise HTTPException(
+                status_code=404,
+                detail=f"No image found for session {session_id}"
+            )
+
+        # Get the most recent file if multiple exist
+        most_recent_file = max(matching_files, key=os.path.getmtime)
+        logger.info(f"Found session image for session {session_id}: {most_recent_file}")
+
+        # Read the image file
+        image_data = open(most_recent_file, 'rb').read()
+
+        # Return image as binary response
+        return Response(content=image_data, media_type="image/jpeg")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving session image for session {session_id}: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
 @app.get("/health")
 async def health_check():
     """Health check endpoint for monitoring."""
@@ -197,6 +370,205 @@ async def health_check():
     }
 
 
+@app.get("/health/detailed")
+async def detailed_health_check():
+    """Comprehensive health status with detailed monitoring data."""
+    try:
+        from core.monitoring.health import health_monitor
+        from core.monitoring.stream_health import stream_health_tracker
+        from core.monitoring.thread_health import thread_health_monitor
+        from core.monitoring.recovery import recovery_manager
+
+        # Get comprehensive health status
+        overall_health = health_monitor.get_health_status()
+        stream_metrics = stream_health_tracker.get_all_metrics()
+        thread_info = thread_health_monitor.get_all_thread_info()
+        recovery_stats = recovery_manager.get_recovery_stats()
+
+        return {
+            "timestamp": time.time(),
+            "overall_health": overall_health,
+            "stream_metrics": stream_metrics,
+            "thread_health": thread_info,
+            "recovery_stats": recovery_stats,
+            "system_info": {
+                "active_subscriptions": len(worker_state.subscriptions),
+                "active_sessions": len(worker_state.session_ids),
+                "version": "2.0.0"
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error generating detailed health report: {e}")
+        raise HTTPException(status_code=500, detail=f"Health monitoring error: {str(e)}")
+
+
+@app.get("/health/streams")
+async def stream_health_status():
+    """Stream-specific health monitoring."""
+    try:
+        from core.monitoring.stream_health import stream_health_tracker
+        from core.streaming.buffers import shared_cache_buffer
+
+        stream_metrics = stream_health_tracker.get_all_metrics()
+        buffer_stats = shared_cache_buffer.get_stats()
+
+        return {
+            "timestamp": time.time(),
+            "stream_count": len(stream_metrics),
+            "stream_metrics": stream_metrics,
+            "buffer_stats": buffer_stats,
+            "frame_ages": {
+                camera_id: {
+                    "age_seconds": time.time() - info["last_frame_time"] if info and info.get("last_frame_time") else None,
+                    "total_frames": info.get("frame_count", 0) if info else 0
+                }
+                for camera_id, info in stream_metrics.items()
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error generating stream health report: {e}")
+        raise HTTPException(status_code=500, detail=f"Stream health error: {str(e)}")
+
+
+@app.get("/health/threads")
+async def thread_health_status():
+    """Thread-specific health monitoring."""
+    try:
+        from core.monitoring.thread_health import thread_health_monitor
+
+        thread_info = thread_health_monitor.get_all_thread_info()
+        deadlocks = thread_health_monitor.detect_deadlocks()
+
+        return {
+            "timestamp": time.time(),
+            "thread_count": len(thread_info),
+            "thread_info": thread_info,
+            "potential_deadlocks": deadlocks,
+            "summary": {
+                "responsive_threads": sum(1 for info in thread_info.values() if info.get("is_responsive", False)),
+                "unresponsive_threads": sum(1 for info in thread_info.values() if not info.get("is_responsive", True)),
+                "deadlock_count": len(deadlocks)
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error generating thread health report: {e}")
+        raise HTTPException(status_code=500, detail=f"Thread health error: {str(e)}")
+
+
+@app.get("/health/recovery")
+async def recovery_status():
+    """Recovery system status and history."""
+    try:
+        from core.monitoring.recovery import recovery_manager
+
+        recovery_stats = recovery_manager.get_recovery_stats()
+
+        return {
+            "timestamp": time.time(),
+            "recovery_stats": recovery_stats,
+            "summary": {
+                "total_recoveries_last_hour": recovery_stats.get("total_recoveries_last_hour", 0),
+                "components_with_recovery_state": len(recovery_stats.get("recovery_states", {})),
+                "total_recovery_failures": sum(
+                    state.get("failure_count", 0)
+                    for state in recovery_stats.get("recovery_states", {}).values()
+                ),
+                "total_recovery_successes": sum(
+                    state.get("success_count", 0)
+                    for state in recovery_stats.get("recovery_states", {}).values()
+                )
+            }
+        }
+
+    except Exception as e:
+        logger.error(f"Error generating recovery status report: {e}")
+        raise HTTPException(status_code=500, detail=f"Recovery status error: {str(e)}")
+
+
+@app.post("/health/recovery/force/{component}")
+async def force_recovery(component: str, action: str = "restart_stream"):
+    """Force recovery action for a specific component."""
+    try:
+        from core.monitoring.recovery import recovery_manager, RecoveryAction
+
+        # Validate action
+        try:
+            recovery_action = RecoveryAction(action)
+        except ValueError:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid recovery action: {action}. Valid actions: {[a.value for a in RecoveryAction]}"
+            )
+
+        # Force recovery
+        success = recovery_manager.force_recovery(component, recovery_action, "manual_api_request")
+
+        return {
+            "timestamp": time.time(),
+            "component": component,
+            "action": action,
+            "success": success,
+            "message": f"Recovery {'successful' if success else 'failed'} for component {component}"
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error forcing recovery for {component}: {e}")
+        raise HTTPException(status_code=500, detail=f"Recovery error: {str(e)}")
+
+
+@app.get("/health/metrics")
+async def health_metrics():
+    """Performance and health metrics in a format suitable for monitoring systems."""
+    try:
+        from core.monitoring.health import health_monitor
+        from core.monitoring.stream_health import stream_health_tracker
+        from core.streaming.buffers import shared_cache_buffer
+
+        # Get basic metrics
+        overall_health = health_monitor.get_health_status()
+        stream_metrics = stream_health_tracker.get_all_metrics()
+        buffer_stats = shared_cache_buffer.get_stats()
+
+        # Format for monitoring systems (Prometheus-style)
+        metrics = {
+            "detector_worker_up": 1,
+            "detector_worker_streams_total": len(stream_metrics),
+            "detector_worker_subscriptions_total": len(worker_state.subscriptions),
+            "detector_worker_sessions_total": len(worker_state.session_ids),
+            "detector_worker_memory_mb": buffer_stats.get("total_memory_mb", 0),
+            "detector_worker_health_status": {
+                "healthy": 1,
+                "warning": 2,
+                "critical": 3,
+                "unknown": 4
+            }.get(overall_health.get("overall_status", "unknown"), 4)
+        }
+
+        # Add per-stream metrics
+        for camera_id, stream_info in stream_metrics.items():
+            safe_camera_id = camera_id.replace("-", "_").replace(".", "_")
+            metrics.update({
+                f"detector_worker_stream_frames_total{{camera=\"{safe_camera_id}\"}}": stream_info.get("frame_count", 0),
+                f"detector_worker_stream_errors_total{{camera=\"{safe_camera_id}\"}}": stream_info.get("error_count", 0),
+                f"detector_worker_stream_fps{{camera=\"{safe_camera_id}\"}}": stream_info.get("frames_per_second", 0),
+                f"detector_worker_stream_frame_age_seconds{{camera=\"{safe_camera_id}\"}}": stream_info.get("last_frame_age_seconds") or 0
+            })
+
+        return {
+            "timestamp": time.time(),
+            "metrics": metrics
+        }
+
+    except Exception as e:
+        logger.error(f"Error generating health metrics: {e}")
+        raise HTTPException(status_code=500, detail=f"Metrics error: {str(e)}")
+
+
 
 
 if __name__ == "__main__":
diff --git a/archive/app.py b/archive/app.py
new file mode 100644
index 0000000..09cb227
--- /dev/null
+++ b/archive/app.py
@@ -0,0 +1,903 @@
+from typing import Any, Dict
+import os
+import json
+import time
+import queue
+import torch
+import cv2
+import numpy as np
+import base64
+import logging
+import threading
+import requests
+import asyncio
+import psutil
+import zipfile
+from urllib.parse import urlparse
+from fastapi import FastAPI, WebSocket, HTTPException
+from fastapi.websockets import WebSocketDisconnect
+from fastapi.responses import Response
+from websockets.exceptions import ConnectionClosedError
+from ultralytics import YOLO
+
+# Import shared pipeline functions
+from siwatsystem.pympta import load_pipeline_from_zip, run_pipeline
+
+app = FastAPI()
+
+# Global dictionaries to keep track of models and streams
+# "models" now holds a nested dict: { camera_id: { modelId: model_tree } }
+models: Dict[str, Dict[str, Any]] = {}
+streams: Dict[str, Dict[str, Any]] = {}
+# Store session IDs per display
+session_ids: Dict[str, int] = {}
+# Track shared camera streams by camera URL
+camera_streams: Dict[str, Dict[str, Any]] = {}
+# Map subscriptions to their camera URL
+subscription_to_camera: Dict[str, str] = {}
+# Store latest frames for REST API access (separate from processing buffer)
+latest_frames: Dict[str, Any] = {}
+
+with open("config.json", "r") as f:
+    config = json.load(f)
+
+poll_interval = config.get("poll_interval_ms", 100)
+reconnect_interval = config.get("reconnect_interval_sec", 5)
+TARGET_FPS = config.get("target_fps", 10)
+poll_interval = 1000 / TARGET_FPS
+logging.info(f"Poll interval: {poll_interval}ms")
+max_streams = config.get("max_streams", 5)
+max_retries = config.get("max_retries", 3)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,  # Set to INFO level for less verbose output
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    handlers=[
+        logging.FileHandler("detector_worker.log"),  # Write logs to a file
+        logging.StreamHandler()  # Also output to console
+    ]
+)
+
+# Create a logger specifically for this application
+logger = logging.getLogger("detector_worker")
+logger.setLevel(logging.DEBUG)  # Set app-specific logger to DEBUG level
+
+# Ensure all other libraries (including root) use at least INFO level
+logging.getLogger().setLevel(logging.INFO)
+
+logger.info("Starting detector worker application")
+logger.info(f"Configuration: Target FPS: {TARGET_FPS}, Max streams: {max_streams}, Max retries: {max_retries}")
+
+# Ensure the models directory exists
+os.makedirs("models", exist_ok=True)
+logger.info("Ensured models directory exists")
+
+# Constants for heartbeat and timeouts
+HEARTBEAT_INTERVAL = 2  # seconds
+WORKER_TIMEOUT_MS = 10000
+logger.debug(f"Heartbeat interval set to {HEARTBEAT_INTERVAL} seconds")
+
+# Locks for thread-safe operations
+streams_lock = threading.Lock()
+models_lock = threading.Lock()
+logger.debug("Initialized thread locks")
+
+# Add helper to download mpta ZIP file from a remote URL
+def download_mpta(url: str, dest_path: str) -> str:
+    try:
+        logger.info(f"Starting download of model from {url} to {dest_path}")
+        os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+        response = requests.get(url, stream=True)
+        if response.status_code == 200:
+            file_size = int(response.headers.get('content-length', 0))
+            logger.info(f"Model file size: {file_size/1024/1024:.2f} MB")
+            downloaded = 0
+            with open(dest_path, "wb") as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+                    downloaded += len(chunk)
+                    if file_size > 0 and downloaded % (file_size // 10) < 8192:  # Log approximately every 10%
+                        logger.debug(f"Download progress: {downloaded/file_size*100:.1f}%")
+            logger.info(f"Successfully downloaded mpta file from {url} to {dest_path}")
+            return dest_path
+        else:
+            logger.error(f"Failed to download mpta file (status code {response.status_code}): {response.text}")
+            return None
+    except Exception as e:
+        logger.error(f"Exception downloading mpta file from {url}: {str(e)}", exc_info=True)
+        return None
+
+# Add helper to fetch snapshot image from HTTP/HTTPS URL
+def fetch_snapshot(url: str):
+    try:
+        from requests.auth import HTTPBasicAuth, HTTPDigestAuth
+        
+        # Parse URL to extract credentials
+        parsed = urlparse(url)
+        
+        # Prepare headers - some cameras require User-Agent
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (compatible; DetectorWorker/1.0)'
+        }
+        
+        # Reconstruct URL without credentials
+        clean_url = f"{parsed.scheme}://{parsed.hostname}"
+        if parsed.port:
+            clean_url += f":{parsed.port}"
+        clean_url += parsed.path
+        if parsed.query:
+            clean_url += f"?{parsed.query}"
+        
+        auth = None
+        if parsed.username and parsed.password:
+            # Try HTTP Digest authentication first (common for IP cameras)
+            try:
+                auth = HTTPDigestAuth(parsed.username, parsed.password)
+                response = requests.get(clean_url, auth=auth, headers=headers, timeout=10)
+                if response.status_code == 200:
+                    logger.debug(f"Successfully authenticated using HTTP Digest for {clean_url}")
+                elif response.status_code == 401:
+                    # If Digest fails, try Basic auth
+                    logger.debug(f"HTTP Digest failed, trying Basic auth for {clean_url}")
+                    auth = HTTPBasicAuth(parsed.username, parsed.password)
+                    response = requests.get(clean_url, auth=auth, headers=headers, timeout=10)
+                    if response.status_code == 200:
+                        logger.debug(f"Successfully authenticated using HTTP Basic for {clean_url}")
+            except Exception as auth_error:
+                logger.debug(f"Authentication setup error: {auth_error}")
+                # Fallback to original URL with embedded credentials
+                response = requests.get(url, headers=headers, timeout=10)
+        else:
+            # No credentials in URL, make request as-is
+            response = requests.get(url, headers=headers, timeout=10)
+        
+        if response.status_code == 200:
+            # Convert response content to numpy array
+            nparr = np.frombuffer(response.content, np.uint8)
+            # Decode image
+            frame = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+            if frame is not None:
+                logger.debug(f"Successfully fetched snapshot from {clean_url}, shape: {frame.shape}")
+                return frame
+            else:
+                logger.error(f"Failed to decode image from snapshot URL: {clean_url}")
+                return None
+        else:
+            logger.error(f"Failed to fetch snapshot (status code {response.status_code}): {clean_url}")
+            return None
+    except Exception as e:
+        logger.error(f"Exception fetching snapshot from {url}: {str(e)}")
+        return None
+
+# Helper to get crop coordinates from stream
+def get_crop_coords(stream):
+    return {
+        "cropX1": stream.get("cropX1"),
+        "cropY1": stream.get("cropY1"),
+        "cropX2": stream.get("cropX2"),
+        "cropY2": stream.get("cropY2")
+    }
+
+####################################################
+# REST API endpoint for image retrieval
+####################################################
+@app.get("/camera/{camera_id}/image")
+async def get_camera_image(camera_id: str):
+    """
+    Get the current frame from a camera as JPEG image
+    """
+    try:
+        # URL decode the camera_id to handle encoded characters like %3B for semicolon
+        from urllib.parse import unquote
+        original_camera_id = camera_id
+        camera_id = unquote(camera_id)
+        logger.debug(f"REST API request: original='{original_camera_id}', decoded='{camera_id}'")
+        
+        with streams_lock:
+            if camera_id not in streams:
+                logger.warning(f"Camera ID '{camera_id}' not found in streams. Current streams: {list(streams.keys())}")
+                raise HTTPException(status_code=404, detail=f"Camera {camera_id} not found or not active")
+            
+            # Check if we have a cached frame for this camera
+            if camera_id not in latest_frames:
+                logger.warning(f"No cached frame available for camera '{camera_id}'.")
+                raise HTTPException(status_code=404, detail=f"No frame available for camera {camera_id}")
+            
+            frame = latest_frames[camera_id]
+            logger.debug(f"Retrieved cached frame for camera '{camera_id}', frame shape: {frame.shape}")
+        # Encode frame as JPEG
+        success, buffer_img = cv2.imencode('.jpg', frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to encode image as JPEG")
+        
+        # Return image as binary response
+        return Response(content=buffer_img.tobytes(), media_type="image/jpeg")
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error retrieving image for camera {camera_id}: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+####################################################
+# Detection and frame processing functions
+####################################################
+@app.websocket("/")
+async def detect(websocket: WebSocket):
+    logger.info("WebSocket connection accepted")
+    persistent_data_dict = {}
+
+    async def handle_detection(camera_id, stream, frame, websocket, model_tree, persistent_data):
+        try:
+            # Apply crop if specified
+            cropped_frame = frame
+            if all(coord is not None for coord in [stream.get("cropX1"), stream.get("cropY1"), stream.get("cropX2"), stream.get("cropY2")]):
+                cropX1, cropY1, cropX2, cropY2 = stream["cropX1"], stream["cropY1"], stream["cropX2"], stream["cropY2"]
+                cropped_frame = frame[cropY1:cropY2, cropX1:cropX2]
+                logger.debug(f"Applied crop coordinates ({cropX1}, {cropY1}, {cropX2}, {cropY2}) to frame for camera {camera_id}")
+            
+            logger.debug(f"Processing frame for camera {camera_id} with model {stream['modelId']}")
+            start_time = time.time()
+            
+            # Extract display identifier for session ID lookup
+            subscription_parts = stream["subscriptionIdentifier"].split(';')
+            display_identifier = subscription_parts[0] if subscription_parts else None
+            session_id = session_ids.get(display_identifier) if display_identifier else None
+            
+            # Create context for pipeline execution
+            pipeline_context = {
+                "camera_id": camera_id,
+                "display_id": display_identifier,
+                "session_id": session_id
+            }
+            
+            detection_result = run_pipeline(cropped_frame, model_tree, context=pipeline_context)
+            process_time = (time.time() - start_time) * 1000
+            logger.debug(f"Detection for camera {camera_id} completed in {process_time:.2f}ms")
+            
+            # Log the raw detection result for debugging
+            logger.debug(f"Raw detection result for camera {camera_id}:\n{json.dumps(detection_result, indent=2, default=str)}")
+            
+            # Direct class result (no detections/classifications structure)
+            if detection_result and isinstance(detection_result, dict) and "class" in detection_result and "confidence" in detection_result:
+                highest_confidence_detection = {
+                    "class": detection_result.get("class", "none"),
+                    "confidence": detection_result.get("confidence", 1.0),
+                    "box": [0, 0, 0, 0]  # Empty bounding box for classifications
+                }
+            # Handle case when no detections found or result is empty
+            elif not detection_result or not detection_result.get("detections"):
+                # Check if we have classification results
+                if detection_result and detection_result.get("classifications"):
+                    # Get the highest confidence classification
+                    classifications = detection_result.get("classifications", [])
+                    highest_confidence_class = max(classifications, key=lambda x: x.get("confidence", 0)) if classifications else None
+                    
+                    if highest_confidence_class:
+                        highest_confidence_detection = {
+                            "class": highest_confidence_class.get("class", "none"),
+                            "confidence": highest_confidence_class.get("confidence", 1.0),
+                            "box": [0, 0, 0, 0]  # Empty bounding box for classifications
+                        }
+                    else:
+                        highest_confidence_detection = {
+                            "class": "none",
+                            "confidence": 1.0,
+                            "box": [0, 0, 0, 0]
+                        }
+                else:
+                    highest_confidence_detection = {
+                        "class": "none",
+                        "confidence": 1.0,
+                        "box": [0, 0, 0, 0]
+                    }
+            else:
+                # Find detection with highest confidence
+                detections = detection_result.get("detections", [])
+                highest_confidence_detection = max(detections, key=lambda x: x.get("confidence", 0)) if detections else {
+                    "class": "none",
+                    "confidence": 1.0,
+                    "box": [0, 0, 0, 0]
+                }
+            
+            # Convert detection format to match protocol - flatten detection attributes
+            detection_dict = {}
+            
+            # Handle different detection result formats
+            if isinstance(highest_confidence_detection, dict):
+                # Copy all fields from the detection result
+                for key, value in highest_confidence_detection.items():
+                    if key not in ["box", "id"]:  # Skip internal fields
+                        detection_dict[key] = value
+            
+            detection_data = {
+                "type": "imageDetection",
+                "subscriptionIdentifier": stream["subscriptionIdentifier"],
+                "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S.%fZ", time.gmtime()),
+                "data": {
+                    "detection": detection_dict,
+                    "modelId": stream["modelId"],
+                    "modelName": stream["modelName"]
+                }
+            }
+            
+            # Add session ID if available
+            if session_id is not None:
+                detection_data["sessionId"] = session_id
+            
+            if highest_confidence_detection["class"] != "none":
+                logger.info(f"Camera {camera_id}: Detected {highest_confidence_detection['class']} with confidence {highest_confidence_detection['confidence']:.2f} using model {stream['modelName']}")
+                
+                # Log session ID if available
+                if session_id:
+                    logger.debug(f"Detection associated with session ID: {session_id}")
+            
+            await websocket.send_json(detection_data)
+            logger.debug(f"Sent detection data to client for camera {camera_id}")
+            return persistent_data
+        except Exception as e:
+            logger.error(f"Error in handle_detection for camera {camera_id}: {str(e)}", exc_info=True)
+            return persistent_data
+
+    def frame_reader(camera_id, cap, buffer, stop_event):
+        retries = 0
+        logger.info(f"Starting frame reader thread for camera {camera_id}")
+        frame_count = 0
+        last_log_time = time.time()
+        
+        try:
+            # Log initial camera status and properties
+            if cap.isOpened():
+                width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+                height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+                fps = cap.get(cv2.CAP_PROP_FPS)
+                logger.info(f"Camera {camera_id} opened successfully with resolution {width}x{height}, FPS: {fps}")
+            else:
+                logger.error(f"Camera {camera_id} failed to open initially")
+            
+            while not stop_event.is_set():
+                try:
+                    if not cap.isOpened():
+                        logger.error(f"Camera {camera_id} is not open before trying to read")
+                        # Attempt to reopen
+                        cap = cv2.VideoCapture(streams[camera_id]["rtsp_url"])
+                        time.sleep(reconnect_interval)
+                        continue
+                    
+                    logger.debug(f"Attempting to read frame from camera {camera_id}")
+                    ret, frame = cap.read()
+                    
+                    if not ret:
+                        logger.warning(f"Connection lost for camera: {camera_id}, retry {retries+1}/{max_retries}")
+                        cap.release()
+                        time.sleep(reconnect_interval)
+                        retries += 1
+                        if retries > max_retries and max_retries != -1:
+                            logger.error(f"Max retries reached for camera: {camera_id}, stopping frame reader")
+                            break
+                        # Re-open
+                        logger.info(f"Attempting to reopen RTSP stream for camera: {camera_id}")
+                        cap = cv2.VideoCapture(streams[camera_id]["rtsp_url"])
+                        if not cap.isOpened():
+                            logger.error(f"Failed to reopen RTSP stream for camera: {camera_id}")
+                            continue
+                        logger.info(f"Successfully reopened RTSP stream for camera: {camera_id}")
+                        continue
+                    
+                    # Successfully read a frame
+                    frame_count += 1
+                    current_time = time.time()
+                    # Log frame stats every 5 seconds
+                    if current_time - last_log_time > 5:
+                        logger.info(f"Camera {camera_id}: Read {frame_count} frames in the last {current_time - last_log_time:.1f} seconds")
+                        frame_count = 0
+                        last_log_time = current_time
+                    
+                    logger.debug(f"Successfully read frame from camera {camera_id}, shape: {frame.shape}")
+                    retries = 0
+                    
+                    # Overwrite old frame if buffer is full
+                    if not buffer.empty():
+                        try:
+                            buffer.get_nowait()
+                            logger.debug(f"[frame_reader] Removed old frame from buffer for camera {camera_id}")
+                        except queue.Empty:
+                            pass
+                    buffer.put(frame)
+                    logger.debug(f"[frame_reader] Added new frame to buffer for camera {camera_id}. Buffer size: {buffer.qsize()}")
+                    
+                    # Short sleep to avoid CPU overuse
+                    time.sleep(0.01)
+                    
+                except cv2.error as e:
+                    logger.error(f"OpenCV error for camera {camera_id}: {e}", exc_info=True)
+                    cap.release()
+                    time.sleep(reconnect_interval)
+                    retries += 1
+                    if retries > max_retries and max_retries != -1:
+                        logger.error(f"Max retries reached after OpenCV error for camera {camera_id}")
+                        break
+                    logger.info(f"Attempting to reopen RTSP stream after OpenCV error for camera: {camera_id}")
+                    cap = cv2.VideoCapture(streams[camera_id]["rtsp_url"])
+                    if not cap.isOpened():
+                        logger.error(f"Failed to reopen RTSP stream for camera {camera_id} after OpenCV error")
+                        continue
+                    logger.info(f"Successfully reopened RTSP stream after OpenCV error for camera: {camera_id}")
+                except Exception as e:
+                    logger.error(f"Unexpected error for camera {camera_id}: {str(e)}", exc_info=True)
+                    cap.release()
+                    break
+        except Exception as e:
+            logger.error(f"Error in frame_reader thread for camera {camera_id}: {str(e)}", exc_info=True)
+        finally:
+            logger.info(f"Frame reader thread for camera {camera_id} is exiting")
+            if cap and cap.isOpened():
+                cap.release()
+
+    def snapshot_reader(camera_id, snapshot_url, snapshot_interval, buffer, stop_event):
+        """Frame reader that fetches snapshots from HTTP/HTTPS URL at specified intervals"""
+        retries = 0
+        logger.info(f"Starting snapshot reader thread for camera {camera_id} from {snapshot_url}")
+        frame_count = 0
+        last_log_time = time.time()
+        
+        try:
+            interval_seconds = snapshot_interval / 1000.0  # Convert milliseconds to seconds
+            logger.info(f"Snapshot interval for camera {camera_id}: {interval_seconds}s")
+            
+            while not stop_event.is_set():
+                try:
+                    start_time = time.time()
+                    frame = fetch_snapshot(snapshot_url)
+                    
+                    if frame is None:
+                        logger.warning(f"Failed to fetch snapshot for camera: {camera_id}, retry {retries+1}/{max_retries}")
+                        retries += 1
+                        if retries > max_retries and max_retries != -1:
+                            logger.error(f"Max retries reached for snapshot camera: {camera_id}, stopping reader")
+                            break
+                        time.sleep(min(interval_seconds, reconnect_interval))
+                        continue
+                    
+                    # Successfully fetched a frame
+                    frame_count += 1
+                    current_time = time.time()
+                    # Log frame stats every 5 seconds
+                    if current_time - last_log_time > 5:
+                        logger.info(f"Camera {camera_id}: Fetched {frame_count} snapshots in the last {current_time - last_log_time:.1f} seconds")
+                        frame_count = 0
+                        last_log_time = current_time
+                    
+                    logger.debug(f"Successfully fetched snapshot from camera {camera_id}, shape: {frame.shape}")
+                    retries = 0
+                    
+                    # Overwrite old frame if buffer is full
+                    if not buffer.empty():
+                        try:
+                            buffer.get_nowait()
+                            logger.debug(f"[snapshot_reader] Removed old snapshot from buffer for camera {camera_id}")
+                        except queue.Empty:
+                            pass
+                    buffer.put(frame)
+                    logger.debug(f"[snapshot_reader] Added new snapshot to buffer for camera {camera_id}. Buffer size: {buffer.qsize()}")
+                    
+                    # Wait for the specified interval
+                    elapsed = time.time() - start_time
+                    sleep_time = max(interval_seconds - elapsed, 0)
+                    if sleep_time > 0:
+                        time.sleep(sleep_time)
+                
+                except Exception as e:
+                    logger.error(f"Unexpected error fetching snapshot for camera {camera_id}: {str(e)}", exc_info=True)
+                    retries += 1
+                    if retries > max_retries and max_retries != -1:
+                        logger.error(f"Max retries reached after error for snapshot camera {camera_id}")
+                        break
+                    time.sleep(min(interval_seconds, reconnect_interval))
+        except Exception as e:
+            logger.error(f"Error in snapshot_reader thread for camera {camera_id}: {str(e)}", exc_info=True)
+        finally:
+            logger.info(f"Snapshot reader thread for camera {camera_id} is exiting")
+
+    async def process_streams():
+        logger.info("Started processing streams")
+        try:
+            while True:
+                start_time = time.time()
+                with streams_lock:
+                    current_streams = list(streams.items())
+                    if current_streams:
+                        logger.debug(f"Processing {len(current_streams)} active streams")
+                    else:
+                        logger.debug("No active streams to process")
+                
+                for camera_id, stream in current_streams:
+                    buffer = stream["buffer"]
+                    if buffer.empty():
+                        logger.debug(f"Frame buffer is empty for camera {camera_id}")
+                        continue
+                    
+                    logger.debug(f"Got frame from buffer for camera {camera_id}")
+                    frame = buffer.get()
+                    
+                    # Cache the frame for REST API access
+                    latest_frames[camera_id] = frame.copy()
+                    logger.debug(f"Cached frame for REST API access for camera {camera_id}")
+                    
+                    with models_lock:
+                        model_tree = models.get(camera_id, {}).get(stream["modelId"])
+                        if not model_tree:
+                            logger.warning(f"Model not found for camera {camera_id}, modelId {stream['modelId']}")
+                            continue
+                        logger.debug(f"Found model tree for camera {camera_id}, modelId {stream['modelId']}")
+                    
+                    key = (camera_id, stream["modelId"])
+                    persistent_data = persistent_data_dict.get(key, {})
+                    logger.debug(f"Starting detection for camera {camera_id} with modelId {stream['modelId']}")
+                    updated_persistent_data = await handle_detection(
+                        camera_id, stream, frame, websocket, model_tree, persistent_data
+                    )
+                    persistent_data_dict[key] = updated_persistent_data
+                
+                elapsed_time = (time.time() - start_time) * 1000  # ms
+                sleep_time = max(poll_interval - elapsed_time, 0)
+                logger.debug(f"Frame processing cycle: {elapsed_time:.2f}ms, sleeping for: {sleep_time:.2f}ms")
+                await asyncio.sleep(sleep_time / 1000.0)
+        except asyncio.CancelledError:
+            logger.info("Stream processing task cancelled")
+        except Exception as e:
+            logger.error(f"Error in process_streams: {str(e)}", exc_info=True)
+
+    async def send_heartbeat():
+        while True:
+            try:
+                cpu_usage = psutil.cpu_percent()
+                memory_usage = psutil.virtual_memory().percent
+                if torch.cuda.is_available():
+                    gpu_usage = torch.cuda.utilization() if hasattr(torch.cuda, 'utilization') else None
+                    gpu_memory_usage = torch.cuda.memory_reserved() / (1024 ** 2)
+                else:
+                    gpu_usage = None
+                    gpu_memory_usage = None
+
+                camera_connections = [
+                    {
+                        "subscriptionIdentifier": stream["subscriptionIdentifier"],
+                        "modelId": stream["modelId"],
+                        "modelName": stream["modelName"],
+                        "online": True,
+                        **{k: v for k, v in get_crop_coords(stream).items() if v is not None}
+                    }
+                    for camera_id, stream in streams.items()
+                ]
+
+                state_report = {
+                    "type": "stateReport",
+                    "cpuUsage": cpu_usage,
+                    "memoryUsage": memory_usage,
+                    "gpuUsage": gpu_usage,
+                    "gpuMemoryUsage": gpu_memory_usage,
+                    "cameraConnections": camera_connections
+                }
+                await websocket.send_text(json.dumps(state_report))
+                logger.debug(f"Sent stateReport as heartbeat: CPU {cpu_usage:.1f}%, Memory {memory_usage:.1f}%, {len(camera_connections)} active cameras")
+                await asyncio.sleep(HEARTBEAT_INTERVAL)
+            except Exception as e:
+                logger.error(f"Error sending stateReport heartbeat: {e}")
+                break
+
+    async def on_message():
+        while True:
+            try:
+                msg = await websocket.receive_text()
+                logger.debug(f"Received message: {msg}")
+                data = json.loads(msg)
+                msg_type = data.get("type")
+
+                if msg_type == "subscribe":
+                    payload = data.get("payload", {})
+                    subscriptionIdentifier = payload.get("subscriptionIdentifier")
+                    rtsp_url = payload.get("rtspUrl")
+                    snapshot_url = payload.get("snapshotUrl")
+                    snapshot_interval = payload.get("snapshotInterval")
+                    model_url = payload.get("modelUrl")
+                    modelId = payload.get("modelId")
+                    modelName = payload.get("modelName")
+                    cropX1 = payload.get("cropX1")
+                    cropY1 = payload.get("cropY1")
+                    cropX2 = payload.get("cropX2")
+                    cropY2 = payload.get("cropY2")
+
+                    # Extract camera_id from subscriptionIdentifier (format: displayIdentifier;cameraIdentifier)
+                    parts = subscriptionIdentifier.split(';')
+                    if len(parts) != 2:
+                        logger.error(f"Invalid subscriptionIdentifier format: {subscriptionIdentifier}")
+                        continue
+                    
+                    display_identifier, camera_identifier = parts
+                    camera_id = subscriptionIdentifier  # Use full subscriptionIdentifier as camera_id for mapping
+
+                    if model_url:
+                        with models_lock:
+                            if (camera_id not in models) or (modelId not in models[camera_id]):
+                                logger.info(f"Loading model from {model_url} for camera {camera_id}, modelId {modelId}")
+                                extraction_dir = os.path.join("models", camera_identifier, str(modelId))
+                                os.makedirs(extraction_dir, exist_ok=True)
+                                # If model_url is remote, download it first.
+                                parsed = urlparse(model_url)
+                                if parsed.scheme in ("http", "https"):
+                                    logger.info(f"Downloading remote .mpta file from {model_url}")
+                                    filename = os.path.basename(parsed.path) or f"model_{modelId}.mpta"
+                                    local_mpta = os.path.join(extraction_dir, filename)
+                                    logger.debug(f"Download destination: {local_mpta}")
+                                    local_path = download_mpta(model_url, local_mpta)
+                                    if not local_path:
+                                        logger.error(f"Failed to download the remote .mpta file from {model_url}")
+                                        error_response = {
+                                            "type": "error",
+                                            "subscriptionIdentifier": subscriptionIdentifier,
+                                            "error": f"Failed to download model from {model_url}"
+                                        }
+                                        await websocket.send_json(error_response)
+                                        continue
+                                    model_tree = load_pipeline_from_zip(local_path, extraction_dir)
+                                else:
+                                    logger.info(f"Loading local .mpta file from {model_url}")
+                                    # Check if file exists before attempting to load
+                                    if not os.path.exists(model_url):
+                                        logger.error(f"Local .mpta file not found: {model_url}")
+                                        logger.debug(f"Current working directory: {os.getcwd()}")
+                                        error_response = {
+                                            "type": "error",
+                                            "subscriptionIdentifier": subscriptionIdentifier,
+                                            "error": f"Model file not found: {model_url}"
+                                        }
+                                        await websocket.send_json(error_response)
+                                        continue
+                                    model_tree = load_pipeline_from_zip(model_url, extraction_dir)
+                                if model_tree is None:
+                                    logger.error(f"Failed to load model {modelId} from .mpta file for camera {camera_id}")
+                                    error_response = {
+                                        "type": "error",
+                                        "subscriptionIdentifier": subscriptionIdentifier,
+                                        "error": f"Failed to load model {modelId}"
+                                    }
+                                    await websocket.send_json(error_response)
+                                    continue
+                                if camera_id not in models:
+                                    models[camera_id] = {}
+                                models[camera_id][modelId] = model_tree
+                                logger.info(f"Successfully loaded model {modelId} for camera {camera_id}")
+                                logger.debug(f"Model extraction directory: {extraction_dir}")
+                    if camera_id and (rtsp_url or snapshot_url):
+                        with streams_lock:
+                            # Determine camera URL for shared stream management
+                            camera_url = snapshot_url if snapshot_url else rtsp_url
+                            
+                            if camera_id not in streams and len(streams) < max_streams:
+                                # Check if we already have a stream for this camera URL
+                                shared_stream = camera_streams.get(camera_url)
+                                
+                                if shared_stream:
+                                    # Reuse existing stream
+                                    logger.info(f"Reusing existing stream for camera URL: {camera_url}")
+                                    buffer = shared_stream["buffer"]
+                                    stop_event = shared_stream["stop_event"]
+                                    thread = shared_stream["thread"]
+                                    mode = shared_stream["mode"]
+                                    
+                                    # Increment reference count
+                                    shared_stream["ref_count"] = shared_stream.get("ref_count", 0) + 1
+                                else:
+                                    # Create new stream
+                                    buffer = queue.Queue(maxsize=1)
+                                    stop_event = threading.Event()
+                                    
+                                    if snapshot_url and snapshot_interval:
+                                        logger.info(f"Creating new snapshot stream for camera {camera_id}: {snapshot_url}")
+                                        thread = threading.Thread(target=snapshot_reader, args=(camera_id, snapshot_url, snapshot_interval, buffer, stop_event))
+                                        thread.daemon = True
+                                        thread.start()
+                                        mode = "snapshot"
+                                        
+                                        # Store shared stream info
+                                        shared_stream = {
+                                            "buffer": buffer,
+                                            "thread": thread,
+                                            "stop_event": stop_event,
+                                            "mode": mode,
+                                            "url": snapshot_url,
+                                            "snapshot_interval": snapshot_interval,
+                                            "ref_count": 1
+                                        }
+                                        camera_streams[camera_url] = shared_stream
+                                        
+                                    elif rtsp_url:
+                                        logger.info(f"Creating new RTSP stream for camera {camera_id}: {rtsp_url}")
+                                        cap = cv2.VideoCapture(rtsp_url)
+                                        if not cap.isOpened():
+                                            logger.error(f"Failed to open RTSP stream for camera {camera_id}")
+                                            continue
+                                        thread = threading.Thread(target=frame_reader, args=(camera_id, cap, buffer, stop_event))
+                                        thread.daemon = True
+                                        thread.start()
+                                        mode = "rtsp"
+                                        
+                                        # Store shared stream info
+                                        shared_stream = {
+                                            "buffer": buffer,
+                                            "thread": thread,
+                                            "stop_event": stop_event,
+                                            "mode": mode,
+                                            "url": rtsp_url,
+                                            "cap": cap,
+                                            "ref_count": 1
+                                        }
+                                        camera_streams[camera_url] = shared_stream
+                                    else:
+                                        logger.error(f"No valid URL provided for camera {camera_id}")
+                                        continue
+                                
+                                # Create stream info for this subscription
+                                stream_info = {
+                                    "buffer": buffer,
+                                    "thread": thread,
+                                    "stop_event": stop_event,
+                                    "modelId": modelId,
+                                    "modelName": modelName,
+                                    "subscriptionIdentifier": subscriptionIdentifier,
+                                    "cropX1": cropX1,
+                                    "cropY1": cropY1,
+                                    "cropX2": cropX2,
+                                    "cropY2": cropY2,
+                                    "mode": mode,
+                                    "camera_url": camera_url
+                                }
+                                
+                                if mode == "snapshot":
+                                    stream_info["snapshot_url"] = snapshot_url
+                                    stream_info["snapshot_interval"] = snapshot_interval
+                                elif mode == "rtsp":
+                                    stream_info["rtsp_url"] = rtsp_url
+                                    stream_info["cap"] = shared_stream["cap"]
+                                
+                                streams[camera_id] = stream_info
+                                subscription_to_camera[camera_id] = camera_url
+                                
+                            elif camera_id and camera_id in streams:
+                                # If already subscribed, unsubscribe first
+                                logger.info(f"Resubscribing to camera {camera_id}")
+                                # Note: Keep models in memory for reuse across subscriptions
+                elif msg_type == "unsubscribe":
+                    payload = data.get("payload", {})
+                    subscriptionIdentifier = payload.get("subscriptionIdentifier")
+                    camera_id = subscriptionIdentifier
+                    with streams_lock:
+                        if camera_id and camera_id in streams:
+                            stream = streams.pop(camera_id)
+                            camera_url = subscription_to_camera.pop(camera_id, None)
+                            
+                            if camera_url and camera_url in camera_streams:
+                                shared_stream = camera_streams[camera_url]
+                                shared_stream["ref_count"] -= 1
+                                
+                                # If no more references, stop the shared stream
+                                if shared_stream["ref_count"] <= 0:
+                                    logger.info(f"Stopping shared stream for camera URL: {camera_url}")
+                                    shared_stream["stop_event"].set()
+                                    shared_stream["thread"].join()
+                                    if "cap" in shared_stream:
+                                        shared_stream["cap"].release()
+                                    del camera_streams[camera_url]
+                                else:
+                                    logger.info(f"Shared stream for {camera_url} still has {shared_stream['ref_count']} references")
+                            
+                            # Clean up cached frame
+                            latest_frames.pop(camera_id, None)
+                            logger.info(f"Unsubscribed from camera {camera_id}")
+                            # Note: Keep models in memory for potential reuse
+                elif msg_type == "requestState":
+                    cpu_usage = psutil.cpu_percent()
+                    memory_usage = psutil.virtual_memory().percent
+                    if torch.cuda.is_available():
+                        gpu_usage = torch.cuda.utilization() if hasattr(torch.cuda, 'utilization') else None
+                        gpu_memory_usage = torch.cuda.memory_reserved() / (1024 ** 2)
+                    else:
+                        gpu_usage = None
+                        gpu_memory_usage = None
+
+                    camera_connections = [
+                        {
+                            "subscriptionIdentifier": stream["subscriptionIdentifier"],
+                            "modelId": stream["modelId"],
+                            "modelName": stream["modelName"],
+                            "online": True,
+                            **{k: v for k, v in get_crop_coords(stream).items() if v is not None}
+                        }
+                        for camera_id, stream in streams.items()
+                    ]
+
+                    state_report = {
+                        "type": "stateReport",
+                        "cpuUsage": cpu_usage,
+                        "memoryUsage": memory_usage,
+                        "gpuUsage": gpu_usage,
+                        "gpuMemoryUsage": gpu_memory_usage,
+                        "cameraConnections": camera_connections
+                    }
+                    await websocket.send_text(json.dumps(state_report))
+                
+                elif msg_type == "setSessionId":
+                    payload = data.get("payload", {})
+                    display_identifier = payload.get("displayIdentifier")
+                    session_id = payload.get("sessionId")
+                    
+                    if display_identifier:
+                        # Store session ID for this display
+                        if session_id is None:
+                            session_ids.pop(display_identifier, None)
+                            logger.info(f"Cleared session ID for display {display_identifier}")
+                        else:
+                            session_ids[display_identifier] = session_id
+                            logger.info(f"Set session ID {session_id} for display {display_identifier}")
+                
+                elif msg_type == "patchSession":
+                    session_id = data.get("sessionId")
+                    patch_data = data.get("data", {})
+                    
+                    # For now, just acknowledge the patch - actual implementation depends on backend requirements
+                    response = {
+                        "type": "patchSessionResult",
+                        "payload": {
+                            "sessionId": session_id,
+                            "success": True,
+                            "message": "Session patch acknowledged"
+                        }
+                    }
+                    await websocket.send_json(response)
+                    logger.info(f"Acknowledged patch for session {session_id}")
+                
+                else:
+                    logger.error(f"Unknown message type: {msg_type}")
+            except json.JSONDecodeError:
+                logger.error("Received invalid JSON message")
+            except (WebSocketDisconnect, ConnectionClosedError) as e:
+                logger.warning(f"WebSocket disconnected: {e}")
+                break
+            except Exception as e:
+                logger.error(f"Error handling message: {e}")
+                break
+    try:
+        await websocket.accept()
+        stream_task = asyncio.create_task(process_streams())
+        heartbeat_task = asyncio.create_task(send_heartbeat())
+        message_task = asyncio.create_task(on_message())
+        await asyncio.gather(heartbeat_task, message_task)
+    except Exception as e:
+        logger.error(f"Error in detect websocket: {e}")
+    finally:
+        stream_task.cancel()
+        await stream_task
+        with streams_lock:
+            # Clean up shared camera streams
+            for camera_url, shared_stream in camera_streams.items():
+                shared_stream["stop_event"].set()
+                shared_stream["thread"].join()
+                if "cap" in shared_stream:
+                    shared_stream["cap"].release()
+                while not shared_stream["buffer"].empty():
+                    try:
+                        shared_stream["buffer"].get_nowait()
+                    except queue.Empty:
+                        pass
+                logger.info(f"Released shared camera stream for {camera_url}")
+            
+            streams.clear()
+            camera_streams.clear()
+            subscription_to_camera.clear()
+        with models_lock:
+            models.clear()
+        latest_frames.clear()
+        session_ids.clear()
+        logger.info("WebSocket connection closed")
diff --git a/archive/siwatsystem/database.py b/archive/siwatsystem/database.py
new file mode 100644
index 0000000..6340986
--- /dev/null
+++ b/archive/siwatsystem/database.py
@@ -0,0 +1,211 @@
+import psycopg2
+import psycopg2.extras
+from typing import Optional, Dict, Any
+import logging
+import uuid
+
+logger = logging.getLogger(__name__)
+
+class DatabaseManager:
+    def __init__(self, config: Dict[str, Any]):
+        self.config = config
+        self.connection: Optional[psycopg2.extensions.connection] = None
+        
+    def connect(self) -> bool:
+        try:
+            self.connection = psycopg2.connect(
+                host=self.config['host'],
+                port=self.config['port'],
+                database=self.config['database'],
+                user=self.config['username'],
+                password=self.config['password']
+            )
+            logger.info("PostgreSQL connection established successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect to PostgreSQL: {e}")
+            return False
+    
+    def disconnect(self):
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+            logger.info("PostgreSQL connection closed")
+    
+    def is_connected(self) -> bool:
+        try:
+            if self.connection and not self.connection.closed:
+                cur = self.connection.cursor()
+                cur.execute("SELECT 1")
+                cur.fetchone()
+                cur.close()
+                return True
+        except:
+            pass
+        return False
+    
+    def update_car_info(self, session_id: str, brand: str, model: str, body_type: str) -> bool:
+        if not self.is_connected():
+            if not self.connect():
+                return False
+        
+        try:
+            cur = self.connection.cursor()
+            query = """
+            INSERT INTO car_frontal_info (session_id, car_brand, car_model, car_body_type, updated_at)
+            VALUES (%s, %s, %s, %s, NOW())
+            ON CONFLICT (session_id) 
+            DO UPDATE SET 
+                car_brand = EXCLUDED.car_brand,
+                car_model = EXCLUDED.car_model,
+                car_body_type = EXCLUDED.car_body_type,
+                updated_at = NOW()
+            """
+            cur.execute(query, (session_id, brand, model, body_type))
+            self.connection.commit()
+            cur.close()
+            logger.info(f"Updated car info for session {session_id}: {brand} {model} ({body_type})")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to update car info: {e}")
+            if self.connection:
+                self.connection.rollback()
+            return False
+    
+    def execute_update(self, table: str, key_field: str, key_value: str, fields: Dict[str, str]) -> bool:
+        if not self.is_connected():
+            if not self.connect():
+                return False
+        
+        try:
+            cur = self.connection.cursor()
+            
+            # Build the UPDATE query dynamically
+            set_clauses = []
+            values = []
+            
+            for field, value in fields.items():
+                if value == "NOW()":
+                    set_clauses.append(f"{field} = NOW()")
+                else:
+                    set_clauses.append(f"{field} = %s")
+                    values.append(value)
+            
+            # Add schema prefix if table doesn't already have it
+            full_table_name = table if '.' in table else f"gas_station_1.{table}"
+            
+            query = f"""
+            INSERT INTO {full_table_name} ({key_field}, {', '.join(fields.keys())})
+            VALUES (%s, {', '.join(['%s'] * len(fields))})
+            ON CONFLICT ({key_field})
+            DO UPDATE SET {', '.join(set_clauses)}
+            """
+            
+            # Add key_value to the beginning of values list
+            all_values = [key_value] + list(fields.values()) + values
+            
+            cur.execute(query, all_values)
+            self.connection.commit()
+            cur.close()
+            logger.info(f"Updated {table} for {key_field}={key_value}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to execute update on {table}: {e}")
+            if self.connection:
+                self.connection.rollback()
+            return False
+    
+    def create_car_frontal_info_table(self) -> bool:
+        """Create the car_frontal_info table in gas_station_1 schema if it doesn't exist."""
+        if not self.is_connected():
+            if not self.connect():
+                return False
+        
+        try:
+            cur = self.connection.cursor()
+            
+            # Create schema if it doesn't exist
+            cur.execute("CREATE SCHEMA IF NOT EXISTS gas_station_1")
+            
+            # Create table if it doesn't exist
+            create_table_query = """
+            CREATE TABLE IF NOT EXISTS gas_station_1.car_frontal_info (
+                display_id VARCHAR(255),
+                captured_timestamp VARCHAR(255),
+                session_id VARCHAR(255) PRIMARY KEY,
+                license_character VARCHAR(255) DEFAULT NULL,
+                license_type VARCHAR(255) DEFAULT 'No model available',
+                car_brand VARCHAR(255) DEFAULT NULL,
+                car_model VARCHAR(255) DEFAULT NULL,
+                car_body_type VARCHAR(255) DEFAULT NULL,
+                updated_at TIMESTAMP DEFAULT NOW()
+            )
+            """
+            
+            cur.execute(create_table_query)
+            
+            # Add columns if they don't exist (for existing tables)
+            alter_queries = [
+                "ALTER TABLE gas_station_1.car_frontal_info ADD COLUMN IF NOT EXISTS car_brand VARCHAR(255) DEFAULT NULL",
+                "ALTER TABLE gas_station_1.car_frontal_info ADD COLUMN IF NOT EXISTS car_model VARCHAR(255) DEFAULT NULL", 
+                "ALTER TABLE gas_station_1.car_frontal_info ADD COLUMN IF NOT EXISTS car_body_type VARCHAR(255) DEFAULT NULL",
+                "ALTER TABLE gas_station_1.car_frontal_info ADD COLUMN IF NOT EXISTS updated_at TIMESTAMP DEFAULT NOW()"
+            ]
+            
+            for alter_query in alter_queries:
+                try:
+                    cur.execute(alter_query)
+                    logger.debug(f"Executed: {alter_query}")
+                except Exception as e:
+                    # Ignore errors if column already exists (for older PostgreSQL versions)
+                    if "already exists" in str(e).lower():
+                        logger.debug(f"Column already exists, skipping: {alter_query}")
+                    else:
+                        logger.warning(f"Error in ALTER TABLE: {e}")
+            
+            self.connection.commit()
+            cur.close()
+            logger.info("Successfully created/verified car_frontal_info table with all required columns")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to create car_frontal_info table: {e}")
+            if self.connection:
+                self.connection.rollback()
+            return False
+    
+    def insert_initial_detection(self, display_id: str, captured_timestamp: str, session_id: str = None) -> str:
+        """Insert initial detection record and return the session_id."""
+        if not self.is_connected():
+            if not self.connect():
+                return None
+        
+        # Generate session_id if not provided
+        if not session_id:
+            session_id = str(uuid.uuid4())
+        
+        try:
+            # Ensure table exists
+            if not self.create_car_frontal_info_table():
+                logger.error("Failed to create/verify table before insertion")
+                return None
+            
+            cur = self.connection.cursor()
+            insert_query = """
+            INSERT INTO gas_station_1.car_frontal_info 
+            (display_id, captured_timestamp, session_id, license_character, license_type, car_brand, car_model, car_body_type)
+            VALUES (%s, %s, %s, NULL, 'No model available', NULL, NULL, NULL)
+            ON CONFLICT (session_id) DO NOTHING
+            """
+            
+            cur.execute(insert_query, (display_id, captured_timestamp, session_id))
+            self.connection.commit()
+            cur.close()
+            logger.info(f"Inserted initial detection record with session_id: {session_id}")
+            return session_id
+            
+        except Exception as e:
+            logger.error(f"Failed to insert initial detection record: {e}")
+            if self.connection:
+                self.connection.rollback()
+            return None
\ No newline at end of file
diff --git a/archive/siwatsystem/pympta.py b/archive/siwatsystem/pympta.py
new file mode 100644
index 0000000..d21232d
--- /dev/null
+++ b/archive/siwatsystem/pympta.py
@@ -0,0 +1,798 @@
+import os
+import json
+import logging
+import torch
+import cv2
+import zipfile
+import shutil
+import traceback
+import redis
+import time
+import uuid
+import concurrent.futures
+from ultralytics import YOLO
+from urllib.parse import urlparse
+from .database import DatabaseManager
+
+# Create a logger specifically for this module
+logger = logging.getLogger("detector_worker.pympta")
+
+def validate_redis_config(redis_config: dict) -> bool:
+    """Validate Redis configuration parameters."""
+    required_fields = ["host", "port"]
+    for field in required_fields:
+        if field not in redis_config:
+            logger.error(f"Missing required Redis config field: {field}")
+            return False
+    
+    if not isinstance(redis_config["port"], int) or redis_config["port"] <= 0:
+        logger.error(f"Invalid Redis port: {redis_config['port']}")
+        return False
+    
+    return True
+
+def validate_postgresql_config(pg_config: dict) -> bool:
+    """Validate PostgreSQL configuration parameters."""
+    required_fields = ["host", "port", "database", "username", "password"]
+    for field in required_fields:
+        if field not in pg_config:
+            logger.error(f"Missing required PostgreSQL config field: {field}")
+            return False
+    
+    if not isinstance(pg_config["port"], int) or pg_config["port"] <= 0:
+        logger.error(f"Invalid PostgreSQL port: {pg_config['port']}")
+        return False
+    
+    return True
+
+def crop_region_by_class(frame, regions_dict, class_name):
+    """Crop a specific region from frame based on detected class."""
+    if class_name not in regions_dict:
+        logger.warning(f"Class '{class_name}' not found in detected regions")
+        return None
+    
+    bbox = regions_dict[class_name]['bbox']
+    x1, y1, x2, y2 = bbox
+    cropped = frame[y1:y2, x1:x2]
+    
+    if cropped.size == 0:
+        logger.warning(f"Empty crop for class '{class_name}' with bbox {bbox}")
+        return None
+    
+    return cropped
+
+def format_action_context(base_context, additional_context=None):
+    """Format action context with dynamic values."""
+    context = {**base_context}
+    if additional_context:
+        context.update(additional_context)
+    return context
+
+def load_pipeline_node(node_config: dict, mpta_dir: str, redis_client, db_manager=None) -> dict:
+    # Recursively load a model node from configuration.
+    model_path = os.path.join(mpta_dir, node_config["modelFile"])
+    if not os.path.exists(model_path):
+        logger.error(f"Model file {model_path} not found. Current directory: {os.getcwd()}")
+        logger.error(f"Directory content: {os.listdir(os.path.dirname(model_path))}")
+        raise FileNotFoundError(f"Model file {model_path} not found.")
+    logger.info(f"Loading model for node {node_config['modelId']} from {model_path}")
+    model = YOLO(model_path)
+    if torch.cuda.is_available():
+        logger.info(f"CUDA available. Moving model {node_config['modelId']} to GPU")
+        model.to("cuda")
+    else:
+        logger.info(f"CUDA not available. Using CPU for model {node_config['modelId']}")
+
+    # Prepare trigger class indices for optimization
+    trigger_classes = node_config.get("triggerClasses", [])
+    trigger_class_indices = None
+    if trigger_classes and hasattr(model, "names"):
+        # Convert class names to indices for the model
+        trigger_class_indices = [i for i, name in model.names.items() 
+                                if name in trigger_classes]
+        logger.debug(f"Converted trigger classes to indices: {trigger_class_indices}")
+
+    node = {
+        "modelId": node_config["modelId"],
+        "modelFile": node_config["modelFile"],
+        "triggerClasses": trigger_classes,
+        "triggerClassIndices": trigger_class_indices,
+        "crop": node_config.get("crop", False),
+        "cropClass": node_config.get("cropClass"),
+        "minConfidence": node_config.get("minConfidence", None),
+        "multiClass": node_config.get("multiClass", False),
+        "expectedClasses": node_config.get("expectedClasses", []),
+        "parallel": node_config.get("parallel", False),
+        "actions": node_config.get("actions", []),
+        "parallelActions": node_config.get("parallelActions", []),
+        "model": model,
+        "branches": [],
+        "redis_client": redis_client,
+        "db_manager": db_manager
+    }
+    logger.debug(f"Configured node {node_config['modelId']} with trigger classes: {node['triggerClasses']}")
+    for child in node_config.get("branches", []):
+        logger.debug(f"Loading branch for parent node {node_config['modelId']}")
+        node["branches"].append(load_pipeline_node(child, mpta_dir, redis_client, db_manager))
+    return node
+
+def load_pipeline_from_zip(zip_source: str, target_dir: str) -> dict:
+    logger.info(f"Attempting to load pipeline from {zip_source} to {target_dir}")
+    os.makedirs(target_dir, exist_ok=True)
+    zip_path = os.path.join(target_dir, "pipeline.mpta")
+    
+    # Parse the source; only local files are supported here.
+    parsed = urlparse(zip_source)
+    if parsed.scheme in ("", "file"):
+        local_path = parsed.path if parsed.scheme == "file" else zip_source
+        logger.debug(f"Checking if local file exists: {local_path}")
+        if os.path.exists(local_path):
+            try:
+                shutil.copy(local_path, zip_path)
+                logger.info(f"Copied local .mpta file from {local_path} to {zip_path}")
+            except Exception as e:
+                logger.error(f"Failed to copy local .mpta file from {local_path}: {str(e)}", exc_info=True)
+                return None
+        else:
+            logger.error(f"Local file {local_path} does not exist. Current directory: {os.getcwd()}")
+            # List all subdirectories of models directory to help debugging
+            if os.path.exists("models"):
+                logger.error(f"Content of models directory: {os.listdir('models')}")
+                for root, dirs, files in os.walk("models"):
+                    logger.error(f"Directory {root} contains subdirs: {dirs} and files: {files}")
+            else:
+                logger.error("The models directory doesn't exist")
+            return None
+    else:
+        logger.error(f"HTTP download functionality has been moved. Use a local file path here. Received: {zip_source}")
+        return None
+
+    try:
+        if not os.path.exists(zip_path):
+            logger.error(f"Zip file not found at expected location: {zip_path}")
+            return None
+            
+        logger.debug(f"Extracting .mpta file from {zip_path} to {target_dir}")
+        # Extract contents and track the directories created
+        extracted_dirs = []
+        with zipfile.ZipFile(zip_path, "r") as zip_ref:
+            file_list = zip_ref.namelist()
+            logger.debug(f"Files in .mpta archive: {file_list}")
+            
+            # Extract and track the top-level directories
+            for file_path in file_list:
+                parts = file_path.split('/')
+                if len(parts) > 1:
+                    top_dir = parts[0]
+                    if top_dir and top_dir not in extracted_dirs:
+                        extracted_dirs.append(top_dir)
+            
+            # Now extract the files
+            zip_ref.extractall(target_dir)
+            
+        logger.info(f"Successfully extracted .mpta file to {target_dir}")
+        logger.debug(f"Extracted directories: {extracted_dirs}")
+        
+        # Check what was actually created after extraction
+        actual_dirs = [d for d in os.listdir(target_dir) if os.path.isdir(os.path.join(target_dir, d))]
+        logger.debug(f"Actual directories created: {actual_dirs}")
+    except zipfile.BadZipFile as e:
+        logger.error(f"Bad zip file {zip_path}: {str(e)}", exc_info=True)
+        return None
+    except Exception as e:
+        logger.error(f"Failed to extract .mpta file {zip_path}: {str(e)}", exc_info=True)
+        return None
+    finally:
+        if os.path.exists(zip_path):
+            os.remove(zip_path)
+            logger.debug(f"Removed temporary zip file: {zip_path}")
+
+    # Use the first extracted directory if it exists, otherwise use the expected name
+    pipeline_name = os.path.basename(zip_source)
+    pipeline_name = os.path.splitext(pipeline_name)[0]
+    
+    # Find the directory with pipeline.json
+    mpta_dir = None
+    # First try the expected directory name
+    expected_dir = os.path.join(target_dir, pipeline_name)
+    if os.path.exists(expected_dir) and os.path.exists(os.path.join(expected_dir, "pipeline.json")):
+        mpta_dir = expected_dir
+        logger.debug(f"Found pipeline.json in the expected directory: {mpta_dir}")
+    else:
+        # Look through all subdirectories for pipeline.json
+        for subdir in actual_dirs:
+            potential_dir = os.path.join(target_dir, subdir)
+            if os.path.exists(os.path.join(potential_dir, "pipeline.json")):
+                mpta_dir = potential_dir
+                logger.info(f"Found pipeline.json in directory: {mpta_dir} (different from expected: {expected_dir})")
+                break
+    
+    if not mpta_dir:
+        logger.error(f"Could not find pipeline.json in any extracted directory. Directory content: {os.listdir(target_dir)}")
+        return None
+        
+    pipeline_json_path = os.path.join(mpta_dir, "pipeline.json")
+    if not os.path.exists(pipeline_json_path):
+        logger.error(f"pipeline.json not found in the .mpta file. Files in directory: {os.listdir(mpta_dir)}")
+        return None
+
+    try:
+        with open(pipeline_json_path, "r") as f:
+            pipeline_config = json.load(f)
+        logger.info(f"Successfully loaded pipeline configuration from {pipeline_json_path}")
+        logger.debug(f"Pipeline config: {json.dumps(pipeline_config, indent=2)}")
+        
+        # Establish Redis connection if configured
+        redis_client = None
+        if "redis" in pipeline_config:
+            redis_config = pipeline_config["redis"]
+            if not validate_redis_config(redis_config):
+                logger.error("Invalid Redis configuration, skipping Redis connection")
+            else:
+                try:
+                    redis_client = redis.Redis(
+                        host=redis_config["host"],
+                        port=redis_config["port"],
+                        password=redis_config.get("password"),
+                        db=redis_config.get("db", 0),
+                        decode_responses=True
+                    )
+                    redis_client.ping()
+                    logger.info(f"Successfully connected to Redis at {redis_config['host']}:{redis_config['port']}")
+                except redis.exceptions.ConnectionError as e:
+                    logger.error(f"Failed to connect to Redis: {e}")
+                    redis_client = None
+        
+        # Establish PostgreSQL connection if configured
+        db_manager = None
+        if "postgresql" in pipeline_config:
+            pg_config = pipeline_config["postgresql"]
+            if not validate_postgresql_config(pg_config):
+                logger.error("Invalid PostgreSQL configuration, skipping database connection")
+            else:
+                try:
+                    db_manager = DatabaseManager(pg_config)
+                    if db_manager.connect():
+                        logger.info(f"Successfully connected to PostgreSQL at {pg_config['host']}:{pg_config['port']}")
+                    else:
+                        logger.error("Failed to connect to PostgreSQL")
+                        db_manager = None
+                except Exception as e:
+                    logger.error(f"Error initializing PostgreSQL connection: {e}")
+                    db_manager = None
+        
+        return load_pipeline_node(pipeline_config["pipeline"], mpta_dir, redis_client, db_manager)
+    except json.JSONDecodeError as e:
+        logger.error(f"Error parsing pipeline.json: {str(e)}", exc_info=True)
+        return None
+    except KeyError as e:
+        logger.error(f"Missing key in pipeline.json: {str(e)}", exc_info=True)
+        return None
+    except Exception as e:
+        logger.error(f"Error loading pipeline.json: {str(e)}", exc_info=True)
+        return None
+
+def execute_actions(node, frame, detection_result, regions_dict=None):
+    if not node["redis_client"] or not node["actions"]:
+        return
+
+    # Create a dynamic context for this detection event
+    from datetime import datetime
+    action_context = {
+        **detection_result,
+        "timestamp_ms": int(time.time() * 1000),
+        "uuid": str(uuid.uuid4()),
+        "timestamp": datetime.now().strftime("%Y-%m-%dT%H-%M-%S"),
+        "filename": f"{uuid.uuid4()}.jpg"
+    }
+
+    for action in node["actions"]:
+        try:
+            if action["type"] == "redis_save_image":
+                key = action["key"].format(**action_context)
+                
+                # Check if we need to crop a specific region
+                region_name = action.get("region")
+                image_to_save = frame
+                
+                if region_name and regions_dict:
+                    cropped_image = crop_region_by_class(frame, regions_dict, region_name)
+                    if cropped_image is not None:
+                        image_to_save = cropped_image
+                        logger.debug(f"Cropped region '{region_name}' for redis_save_image")
+                    else:
+                        logger.warning(f"Could not crop region '{region_name}', saving full frame instead")
+                
+                # Encode image with specified format and quality (default to JPEG)
+                img_format = action.get("format", "jpeg").lower()
+                quality = action.get("quality", 90)
+                
+                if img_format == "jpeg":
+                    encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
+                    success, buffer = cv2.imencode('.jpg', image_to_save, encode_params)
+                elif img_format == "png":
+                    success, buffer = cv2.imencode('.png', image_to_save)
+                else:
+                    success, buffer = cv2.imencode('.jpg', image_to_save, [cv2.IMWRITE_JPEG_QUALITY, quality])
+                
+                if not success:
+                    logger.error(f"Failed to encode image for redis_save_image")
+                    continue
+                
+                expire_seconds = action.get("expire_seconds")
+                if expire_seconds:
+                    node["redis_client"].setex(key, expire_seconds, buffer.tobytes())
+                    logger.info(f"Saved image to Redis with key: {key} (expires in {expire_seconds}s)")
+                else:
+                    node["redis_client"].set(key, buffer.tobytes())
+                    logger.info(f"Saved image to Redis with key: {key}")
+                action_context["image_key"] = key
+            elif action["type"] == "redis_publish":
+                channel = action["channel"]
+                try:
+                    # Handle JSON message format by creating it programmatically
+                    message_template = action["message"]
+                    
+                    # Check if the message is JSON-like (starts and ends with braces)
+                    if message_template.strip().startswith('{') and message_template.strip().endswith('}'):
+                        # Create JSON data programmatically to avoid formatting issues
+                        json_data = {}
+                        
+                        # Add common fields
+                        json_data["event"] = "frontal_detected"
+                        json_data["display_id"] = action_context.get("display_id", "unknown")
+                        json_data["session_id"] = action_context.get("session_id")
+                        json_data["timestamp"] = action_context.get("timestamp", "")
+                        json_data["image_key"] = action_context.get("image_key", "")
+                        
+                        # Convert to JSON string
+                        message = json.dumps(json_data)
+                    else:
+                        # Use regular string formatting for non-JSON messages
+                        message = message_template.format(**action_context)
+                    
+                    # Publish to Redis
+                    if not node["redis_client"]:
+                        logger.error("Redis client is None, cannot publish message")
+                        continue
+                        
+                    # Test Redis connection
+                    try:
+                        node["redis_client"].ping()
+                        logger.debug("Redis connection is active")
+                    except Exception as ping_error:
+                        logger.error(f"Redis connection test failed: {ping_error}")
+                        continue
+                    
+                    result = node["redis_client"].publish(channel, message)
+                    logger.info(f"Published message to Redis channel '{channel}': {message}")
+                    logger.info(f"Redis publish result (subscribers count): {result}")
+                    
+                    # Additional debug info
+                    if result == 0:
+                        logger.warning(f"No subscribers listening to channel '{channel}'")
+                    else:
+                        logger.info(f"Message delivered to {result} subscriber(s)")
+                    
+                except KeyError as e:
+                    logger.error(f"Missing key in redis_publish message template: {e}")
+                    logger.debug(f"Available context keys: {list(action_context.keys())}")
+                except Exception as e:
+                    logger.error(f"Error in redis_publish action: {e}")
+                    logger.debug(f"Message template: {action['message']}")
+                    logger.debug(f"Available context keys: {list(action_context.keys())}")
+                    import traceback
+                    logger.debug(f"Full traceback: {traceback.format_exc()}")
+        except Exception as e:
+            logger.error(f"Error executing action {action['type']}: {e}")
+
+def execute_parallel_actions(node, frame, detection_result, regions_dict):
+    """Execute parallel actions after all required branches have completed."""
+    if not node.get("parallelActions"):
+        return
+    
+    logger.debug("Executing parallel actions...")
+    branch_results = detection_result.get("branch_results", {})
+    
+    for action in node["parallelActions"]:
+        try:
+            action_type = action.get("type")
+            logger.debug(f"Processing parallel action: {action_type}")
+            
+            if action_type == "postgresql_update_combined":
+                # Check if all required branches have completed
+                wait_for_branches = action.get("waitForBranches", [])
+                missing_branches = [branch for branch in wait_for_branches if branch not in branch_results]
+                
+                if missing_branches:
+                    logger.warning(f"Cannot execute postgresql_update_combined: missing branch results for {missing_branches}")
+                    continue
+                
+                logger.info(f"All required branches completed: {wait_for_branches}")
+                
+                # Execute the database update
+                execute_postgresql_update_combined(node, action, detection_result, branch_results)
+            else:
+                logger.warning(f"Unknown parallel action type: {action_type}")
+                
+        except Exception as e:
+            logger.error(f"Error executing parallel action {action.get('type', 'unknown')}: {e}")
+            import traceback
+            logger.debug(f"Full traceback: {traceback.format_exc()}")
+
+def execute_postgresql_update_combined(node, action, detection_result, branch_results):
+    """Execute a PostgreSQL update with combined branch results."""
+    if not node.get("db_manager"):
+        logger.error("No database manager available for postgresql_update_combined action")
+        return
+        
+    try:
+        table = action["table"]
+        key_field = action["key_field"]
+        key_value_template = action["key_value"]
+        fields = action["fields"]
+        
+        # Create context for key value formatting
+        action_context = {**detection_result}
+        key_value = key_value_template.format(**action_context)
+        
+        logger.info(f"Executing database update: table={table}, {key_field}={key_value}")
+        
+        # Process field mappings
+        mapped_fields = {}
+        for db_field, value_template in fields.items():
+            try:
+                mapped_value = resolve_field_mapping(value_template, branch_results, action_context)
+                if mapped_value is not None:
+                    mapped_fields[db_field] = mapped_value
+                    logger.debug(f"Mapped field: {db_field} = {mapped_value}")
+                else:
+                    logger.warning(f"Could not resolve field mapping for {db_field}: {value_template}")
+            except Exception as e:
+                logger.error(f"Error mapping field {db_field} with template '{value_template}': {e}")
+        
+        if not mapped_fields:
+            logger.warning("No fields mapped successfully, skipping database update")
+            return
+            
+        # Execute the database update
+        success = node["db_manager"].execute_update(table, key_field, key_value, mapped_fields)
+        
+        if success:
+            logger.info(f"Successfully updated database: {table} with {len(mapped_fields)} fields")
+        else:
+            logger.error(f"Failed to update database: {table}")
+            
+    except KeyError as e:
+        logger.error(f"Missing required field in postgresql_update_combined action: {e}")
+    except Exception as e:
+        logger.error(f"Error in postgresql_update_combined action: {e}")
+        import traceback
+        logger.debug(f"Full traceback: {traceback.format_exc()}")
+
+def resolve_field_mapping(value_template, branch_results, action_context):
+    """Resolve field mapping templates like {car_brand_cls_v1.brand}."""
+    try:
+        # Handle simple context variables first (non-branch references)
+        if not '.' in value_template:
+            return value_template.format(**action_context)
+        
+        # Handle branch result references like {model_id.field}
+        import re
+        branch_refs = re.findall(r'\{([^}]+\.[^}]+)\}', value_template)
+        
+        resolved_template = value_template
+        for ref in branch_refs:
+            try:
+                model_id, field_name = ref.split('.', 1)
+                
+                if model_id in branch_results:
+                    branch_data = branch_results[model_id]
+                    if field_name in branch_data:
+                        field_value = branch_data[field_name]
+                        resolved_template = resolved_template.replace(f'{{{ref}}}', str(field_value))
+                        logger.debug(f"Resolved {ref} to {field_value}")
+                    else:
+                        logger.warning(f"Field '{field_name}' not found in branch '{model_id}' results. Available fields: {list(branch_data.keys())}")
+                        return None
+                else:
+                    logger.warning(f"Branch '{model_id}' not found in results. Available branches: {list(branch_results.keys())}")
+                    return None
+            except ValueError as e:
+                logger.error(f"Invalid branch reference format: {ref}")
+                return None
+        
+        # Format any remaining simple variables
+        try:
+            final_value = resolved_template.format(**action_context)
+            return final_value
+        except KeyError as e:
+            logger.warning(f"Could not resolve context variable in template: {e}")
+            return resolved_template
+            
+    except Exception as e:
+        logger.error(f"Error resolving field mapping '{value_template}': {e}")
+        return None
+
+def run_pipeline(frame, node: dict, return_bbox: bool=False, context=None):
+    """
+    Enhanced pipeline that supports:
+    - Multi-class detection (detecting multiple classes simultaneously)
+    - Parallel branch processing
+    - Region-based actions and cropping
+    - Context passing for session/camera information
+    """
+    try:
+        task = getattr(node["model"], "task", None)
+
+        # ─── Classification stage ───────────────────────────────────
+        if task == "classify":
+            results = node["model"].predict(frame, stream=False)
+            if not results:
+                return (None, None) if return_bbox else None
+
+            r = results[0]
+            probs = r.probs
+            if probs is None:
+                return (None, None) if return_bbox else None
+
+            top1_idx = int(probs.top1)
+            top1_conf = float(probs.top1conf)
+            class_name = node["model"].names[top1_idx]
+
+            det = {
+                "class": class_name,
+                "confidence": top1_conf,
+                "id": None,
+                class_name: class_name  # Add class name as key for backward compatibility
+            }
+            
+            # Add specific field mappings for database operations based on model type
+            model_id = node.get("modelId", "").lower()
+            if "brand" in model_id or "brand_cls" in model_id:
+                det["brand"] = class_name
+            elif "bodytype" in model_id or "body" in model_id:
+                det["body_type"] = class_name
+            elif "color" in model_id:
+                det["color"] = class_name
+            
+            execute_actions(node, frame, det)
+            return (det, None) if return_bbox else det
+
+        # ─── Detection stage - Multi-class support ──────────────────
+        tk = node["triggerClassIndices"]
+        logger.debug(f"Running detection for node {node['modelId']} with trigger classes: {node.get('triggerClasses', [])} (indices: {tk})")
+        logger.debug(f"Node configuration: minConfidence={node['minConfidence']}, multiClass={node.get('multiClass', False)}")
+        
+        res = node["model"].track(
+            frame,
+            stream=False,
+            persist=True,
+            **({"classes": tk} if tk else {})
+        )[0]
+
+        # Collect all detections above confidence threshold
+        all_detections = []
+        all_boxes = []
+        regions_dict = {}
+        
+        logger.debug(f"Raw detection results from model: {len(res.boxes) if res.boxes is not None else 0} detections")
+        
+        for i, box in enumerate(res.boxes):
+            conf = float(box.cpu().conf[0])
+            cid = int(box.cpu().cls[0])
+            name = node["model"].names[cid]
+            
+            logger.debug(f"Detection {i}: class='{name}' (id={cid}), confidence={conf:.3f}, threshold={node['minConfidence']}")
+            
+            if conf < node["minConfidence"]:
+                logger.debug(f"  -> REJECTED: confidence {conf:.3f} < threshold {node['minConfidence']}")
+                continue
+                
+            xy = box.cpu().xyxy[0]
+            x1, y1, x2, y2 = map(int, xy)
+            bbox = (x1, y1, x2, y2)
+            
+            detection = {
+                "class": name,
+                "confidence": conf,
+                "id": box.id.item() if hasattr(box, "id") else None,
+                "bbox": bbox
+            }
+            
+            all_detections.append(detection)
+            all_boxes.append(bbox)
+            
+            logger.debug(f"  -> ACCEPTED: {name} with confidence {conf:.3f}, bbox={bbox}")
+            
+            # Store highest confidence detection for each class
+            if name not in regions_dict or conf > regions_dict[name]["confidence"]:
+                regions_dict[name] = {
+                    "bbox": bbox,
+                    "confidence": conf,
+                    "detection": detection
+                }
+                logger.debug(f"  -> Updated regions_dict['{name}'] with confidence {conf:.3f}")
+
+        logger.info(f"Detection summary: {len(all_detections)} accepted detections from {len(res.boxes) if res.boxes is not None else 0} total")
+        logger.info(f"Detected classes: {list(regions_dict.keys())}")
+
+        if not all_detections:
+            logger.warning("No detections above confidence threshold - returning null")
+            return (None, None) if return_bbox else None
+
+        # ─── Multi-class validation ─────────────────────────────────
+        if node.get("multiClass", False) and node.get("expectedClasses"):
+            expected_classes = node["expectedClasses"]
+            detected_classes = list(regions_dict.keys())
+            
+            logger.info(f"Multi-class validation: expected={expected_classes}, detected={detected_classes}")
+            
+            # Check if at least one expected class is detected (flexible mode)
+            matching_classes = [cls for cls in expected_classes if cls in detected_classes]
+            missing_classes = [cls for cls in expected_classes if cls not in detected_classes]
+            
+            logger.debug(f"Matching classes: {matching_classes}, Missing classes: {missing_classes}")
+            
+            if not matching_classes:
+                # No expected classes found at all
+                logger.warning(f"PIPELINE REJECTED: No expected classes detected. Expected: {expected_classes}, Detected: {detected_classes}")
+                return (None, None) if return_bbox else None
+            
+            if missing_classes:
+                logger.info(f"Partial multi-class detection: {matching_classes} found, {missing_classes} missing")
+            else:
+                logger.info(f"Complete multi-class detection success: {detected_classes}")
+        else:
+            logger.debug("No multi-class validation - proceeding with all detections")
+
+        # ─── Execute actions with region information ────────────────
+        detection_result = {
+            "detections": all_detections,
+            "regions": regions_dict,
+            **(context or {})
+        }
+        
+        # ─── Create initial database record when Car+Frontal detected ────
+        if node.get("db_manager") and node.get("multiClass", False):
+            # Only create database record if we have both Car and Frontal
+            has_car = "Car" in regions_dict
+            has_frontal = "Frontal" in regions_dict
+            
+            if has_car and has_frontal:
+                # Generate UUID session_id since client session is None for now
+                import uuid as uuid_lib
+                from datetime import datetime
+                generated_session_id = str(uuid_lib.uuid4())
+                
+                # Insert initial detection record
+                display_id = detection_result.get("display_id", "unknown")
+                timestamp = datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
+                
+                inserted_session_id = node["db_manager"].insert_initial_detection(
+                    display_id=display_id,
+                    captured_timestamp=timestamp,
+                    session_id=generated_session_id
+                )
+                
+                if inserted_session_id:
+                    # Update detection_result with the generated session_id for actions and branches
+                    detection_result["session_id"] = inserted_session_id
+                    detection_result["timestamp"] = timestamp  # Update with proper timestamp
+                    logger.info(f"Created initial database record with session_id: {inserted_session_id}")
+            else:
+                logger.debug(f"Database record not created - missing required classes. Has Car: {has_car}, Has Frontal: {has_frontal}")
+        
+        execute_actions(node, frame, detection_result, regions_dict)
+
+        # ─── Parallel branch processing ─────────────────────────────
+        if node["branches"]:
+            branch_results = {}
+            
+            # Filter branches that should be triggered
+            active_branches = []
+            for br in node["branches"]:
+                trigger_classes = br.get("triggerClasses", [])
+                min_conf = br.get("minConfidence", 0)
+                
+                logger.debug(f"Evaluating branch {br['modelId']}: trigger_classes={trigger_classes}, min_conf={min_conf}")
+                
+                # Check if any detected class matches branch trigger
+                branch_triggered = False
+                for det_class in regions_dict:
+                    det_confidence = regions_dict[det_class]["confidence"]
+                    logger.debug(f"  Checking detected class '{det_class}' (confidence={det_confidence:.3f}) against triggers {trigger_classes}")
+                    
+                    if (det_class in trigger_classes and det_confidence >= min_conf):
+                        active_branches.append(br)
+                        branch_triggered = True
+                        logger.info(f"Branch {br['modelId']} activated by class '{det_class}' (conf={det_confidence:.3f} >= {min_conf})")
+                        break
+                
+                if not branch_triggered:
+                    logger.debug(f"Branch {br['modelId']} not triggered - no matching classes or insufficient confidence")
+            
+            if active_branches:
+                if node.get("parallel", False) or any(br.get("parallel", False) for br in active_branches):
+                    # Run branches in parallel
+                    with concurrent.futures.ThreadPoolExecutor(max_workers=len(active_branches)) as executor:
+                        futures = {}
+                        
+                        for br in active_branches:
+                            crop_class = br.get("cropClass", br.get("triggerClasses", [])[0] if br.get("triggerClasses") else None)
+                            sub_frame = frame
+                            
+                            logger.info(f"Starting parallel branch: {br['modelId']}, crop_class: {crop_class}")
+                            
+                            if br.get("crop", False) and crop_class:
+                                cropped = crop_region_by_class(frame, regions_dict, crop_class)
+                                if cropped is not None:
+                                    sub_frame = cv2.resize(cropped, (224, 224))
+                                    logger.debug(f"Successfully cropped {crop_class} region for {br['modelId']}")
+                                else:
+                                    logger.warning(f"Failed to crop {crop_class} region for {br['modelId']}, skipping branch")
+                                    continue
+                            
+                            future = executor.submit(run_pipeline, sub_frame, br, True, context)
+                            futures[future] = br
+                        
+                        # Collect results
+                        for future in concurrent.futures.as_completed(futures):
+                            br = futures[future]
+                            try:
+                                result, _ = future.result()
+                                if result:
+                                    branch_results[br["modelId"]] = result
+                                    logger.info(f"Branch {br['modelId']} completed: {result}")
+                            except Exception as e:
+                                logger.error(f"Branch {br['modelId']} failed: {e}")
+                else:
+                    # Run branches sequentially  
+                    for br in active_branches:
+                        crop_class = br.get("cropClass", br.get("triggerClasses", [])[0] if br.get("triggerClasses") else None)
+                        sub_frame = frame
+                        
+                        logger.info(f"Starting sequential branch: {br['modelId']}, crop_class: {crop_class}")
+                        
+                        if br.get("crop", False) and crop_class:
+                            cropped = crop_region_by_class(frame, regions_dict, crop_class)
+                            if cropped is not None:
+                                sub_frame = cv2.resize(cropped, (224, 224))
+                                logger.debug(f"Successfully cropped {crop_class} region for {br['modelId']}")
+                            else:
+                                logger.warning(f"Failed to crop {crop_class} region for {br['modelId']}, skipping branch")
+                                continue
+                        
+                        try:
+                            result, _ = run_pipeline(sub_frame, br, True, context)
+                            if result:
+                                branch_results[br["modelId"]] = result
+                                logger.info(f"Branch {br['modelId']} completed: {result}")
+                            else:
+                                logger.warning(f"Branch {br['modelId']} returned no result")
+                        except Exception as e:
+                            logger.error(f"Error in sequential branch {br['modelId']}: {e}")
+                            import traceback
+                            logger.debug(f"Branch error traceback: {traceback.format_exc()}")
+
+            # Store branch results in detection_result for parallel actions
+            detection_result["branch_results"] = branch_results
+
+        # ─── Execute Parallel Actions ───────────────────────────────
+        if node.get("parallelActions") and "branch_results" in detection_result:
+            execute_parallel_actions(node, frame, detection_result, regions_dict)
+
+        # ─── Return detection result ────────────────────────────────
+        primary_detection = max(all_detections, key=lambda x: x["confidence"])
+        primary_bbox = primary_detection["bbox"]
+        
+        # Add branch results to primary detection for compatibility
+        if "branch_results" in detection_result:
+            primary_detection["branch_results"] = detection_result["branch_results"]
+        
+        return (primary_detection, primary_bbox) if return_bbox else primary_detection
+
+    except Exception as e:
+        logger.error(f"Error in node {node.get('modelId')}: {e}")
+        traceback.print_exc()
+        return (None, None) if return_bbox else None
diff --git a/config.json b/config.json
index 4fd0708..0d061f9 100644
--- a/config.json
+++ b/config.json
@@ -1,14 +1,9 @@
 {
   "poll_interval_ms": 100,
   "max_streams": 20,
-  "target_fps": 4,
+  "target_fps": 2,
   "reconnect_interval_sec": 10,
   "max_retries": -1,
   "rtsp_buffer_size": 3,
-  "rtsp_tcp_transport": true,
-  "use_multiprocessing": true,
-  "max_processes": 10,
-  "frame_queue_size": 100,
-  "process_restart_threshold": 3,
-  "frames_per_second_limit": 6
+  "rtsp_tcp_transport": true
 }
diff --git a/core/communication/session_integration.py b/core/communication/session_integration.py
deleted file mode 100644
index c6a1748..0000000
--- a/core/communication/session_integration.py
+++ /dev/null
@@ -1,319 +0,0 @@
-"""
-Integration layer between WebSocket handler and Session Process Manager.
-Bridges the existing WebSocket protocol with the new session-based architecture.
-"""
-
-import asyncio
-import logging
-from typing import Dict, Any, Optional
-import numpy as np
-
-from ..processes.session_manager import SessionProcessManager
-from ..processes.communication import DetectionResultResponse, ErrorResponse
-from .state import worker_state
-from .messages import serialize_outgoing_message
-# Streaming is now handled directly by session workers - no shared stream manager needed
-
-logger = logging.getLogger(__name__)
-
-
-class SessionWebSocketIntegration:
-    """
-    Integration layer that connects WebSocket protocol with Session Process Manager.
-    Maintains compatibility with existing WebSocket message handling.
-    """
-
-    def __init__(self, websocket_handler=None):
-        """
-        Initialize session WebSocket integration.
-
-        Args:
-            websocket_handler: Reference to WebSocket handler for sending messages
-        """
-        self.websocket_handler = websocket_handler
-        self.session_manager = SessionProcessManager()
-
-        # Track active subscriptions for compatibility
-        self.active_subscriptions: Dict[str, Dict[str, Any]] = {}
-
-        # Set up callbacks
-        self.session_manager.set_detection_result_callback(self._on_detection_result)
-        self.session_manager.set_error_callback(self._on_session_error)
-
-    async def start(self):
-        """Start the session integration."""
-        await self.session_manager.start()
-        logger.info("Session WebSocket integration started")
-
-    async def stop(self):
-        """Stop the session integration."""
-        await self.session_manager.stop()
-        logger.info("Session WebSocket integration stopped")
-
-    async def handle_set_subscription_list(self, message) -> bool:
-        """
-        Handle setSubscriptionList message by managing session processes.
-
-        Args:
-            message: SetSubscriptionListMessage
-
-        Returns:
-            True if successful
-        """
-        try:
-            logger.info(f"Processing subscription list with {len(message.subscriptions)} subscriptions")
-
-            new_subscription_ids = set()
-            for subscription in message.subscriptions:
-                subscription_id = subscription.subscriptionIdentifier
-                new_subscription_ids.add(subscription_id)
-
-                # Check if this is a new subscription
-                if subscription_id not in self.active_subscriptions:
-                    logger.info(f"Creating new session for subscription: {subscription_id}")
-
-                    # Convert subscription to configuration dict
-                    subscription_config = {
-                        'subscriptionIdentifier': subscription.subscriptionIdentifier,
-                        'rtspUrl': getattr(subscription, 'rtspUrl', None),
-                        'snapshotUrl': getattr(subscription, 'snapshotUrl', None),
-                        'snapshotInterval': getattr(subscription, 'snapshotInterval', 5000),
-                        'modelUrl': subscription.modelUrl,
-                        'modelId': subscription.modelId,
-                        'modelName': subscription.modelName,
-                        'cropX1': subscription.cropX1,
-                        'cropY1': subscription.cropY1,
-                        'cropX2': subscription.cropX2,
-                        'cropY2': subscription.cropY2
-                    }
-
-                    # Create session process
-                    success = await self.session_manager.create_session(
-                        subscription_id, subscription_config
-                    )
-
-                    if success:
-                        self.active_subscriptions[subscription_id] = subscription_config
-                        logger.info(f"Session created successfully for {subscription_id}")
-
-                        # Stream handling is now integrated into session worker process
-                    else:
-                        logger.error(f"Failed to create session for {subscription_id}")
-                        return False
-
-                else:
-                    # Update existing subscription configuration if needed
-                    self.active_subscriptions[subscription_id].update({
-                        'modelUrl': subscription.modelUrl,
-                        'modelId': subscription.modelId,
-                        'modelName': subscription.modelName,
-                        'cropX1': subscription.cropX1,
-                        'cropY1': subscription.cropY1,
-                        'cropX2': subscription.cropX2,
-                        'cropY2': subscription.cropY2
-                    })
-
-            # Remove sessions for subscriptions that are no longer active
-            current_subscription_ids = set(self.active_subscriptions.keys())
-            removed_subscriptions = current_subscription_ids - new_subscription_ids
-
-            for subscription_id in removed_subscriptions:
-                logger.info(f"Removing session for subscription: {subscription_id}")
-                await self.session_manager.remove_session(subscription_id)
-                del self.active_subscriptions[subscription_id]
-
-            # Update worker state for compatibility
-            worker_state.set_subscriptions(message.subscriptions)
-
-            logger.info(f"Subscription list processed: {len(new_subscription_ids)} active sessions")
-            return True
-
-        except Exception as e:
-            logger.error(f"Error handling subscription list: {e}", exc_info=True)
-            return False
-
-    async def handle_set_session_id(self, message) -> bool:
-        """
-        Handle setSessionId message by forwarding to appropriate session process.
-
-        Args:
-            message: SetSessionIdMessage
-
-        Returns:
-            True if successful
-        """
-        try:
-            display_id = message.payload.displayIdentifier
-            session_id = message.payload.sessionId
-
-            logger.info(f"Setting session ID {session_id} for display {display_id}")
-
-            # Find subscription identifier for this display
-            subscription_id = None
-            for sub_id in self.active_subscriptions.keys():
-                # Extract display identifier from subscription identifier
-                if display_id in sub_id:
-                    subscription_id = sub_id
-                    break
-
-            if not subscription_id:
-                logger.error(f"No active subscription found for display {display_id}")
-                return False
-
-            # Forward to session process
-            success = await self.session_manager.set_session_id(
-                subscription_id, str(session_id), display_id
-            )
-
-            if success:
-                # Update worker state for compatibility
-                worker_state.set_session_id(display_id, session_id)
-                logger.info(f"Session ID {session_id} set successfully for {display_id}")
-            else:
-                logger.error(f"Failed to set session ID {session_id} for {display_id}")
-
-            return success
-
-        except Exception as e:
-            logger.error(f"Error setting session ID: {e}", exc_info=True)
-            return False
-
-    async def process_frame(self, subscription_id: str, frame: np.ndarray, display_id: str, timestamp: float = None) -> bool:
-        """
-        Process frame through appropriate session process.
-
-        Args:
-            subscription_id: Subscription identifier
-            frame: Frame to process
-            display_id: Display identifier
-            timestamp: Frame timestamp
-
-        Returns:
-            True if frame was processed successfully
-        """
-        try:
-            if timestamp is None:
-                timestamp = asyncio.get_event_loop().time()
-
-            # Forward frame to session process
-            success = await self.session_manager.process_frame(
-                subscription_id, frame, display_id, timestamp
-            )
-
-            if not success:
-                logger.warning(f"Failed to process frame for subscription {subscription_id}")
-
-            return success
-
-        except Exception as e:
-            logger.error(f"Error processing frame for {subscription_id}: {e}", exc_info=True)
-            return False
-
-    async def _on_detection_result(self, subscription_id: str, response: DetectionResultResponse):
-        """
-        Handle detection result from session process.
-
-        Args:
-            subscription_id: Subscription identifier
-            response: Detection result response
-        """
-        try:
-            logger.debug(f"Received detection result from {subscription_id}: phase={response.phase}")
-
-            # Send imageDetection message via WebSocket (if needed)
-            if self.websocket_handler and hasattr(self.websocket_handler, 'send_message'):
-                from .models import ImageDetectionMessage, DetectionData
-
-                # Convert response detections to the expected format
-                # The DetectionData expects modelId and modelName, and detection dict
-                detection_data = DetectionData(
-                    detection=response.detections,
-                    modelId=getattr(response, 'model_id', 0),  # Get from response if available
-                    modelName=getattr(response, 'model_name', 'unknown')  # Get from response if available
-                )
-
-                # Convert timestamp to string format if it exists
-                timestamp_str = None
-                if hasattr(response, 'timestamp') and response.timestamp:
-                    from datetime import datetime
-                    if isinstance(response.timestamp, (int, float)):
-                        # Convert Unix timestamp to ISO format string
-                        timestamp_str = datetime.fromtimestamp(response.timestamp).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
-                    else:
-                        timestamp_str = str(response.timestamp)
-
-                detection_message = ImageDetectionMessage(
-                    subscriptionIdentifier=subscription_id,
-                    data=detection_data,
-                    timestamp=timestamp_str
-                )
-
-                serialized = serialize_outgoing_message(detection_message)
-                await self.websocket_handler.send_message(serialized)
-
-        except Exception as e:
-            logger.error(f"Error handling detection result from {subscription_id}: {e}", exc_info=True)
-
-    async def _on_session_error(self, subscription_id: str, error_response: ErrorResponse):
-        """
-        Handle error from session process.
-
-        Args:
-            subscription_id: Subscription identifier
-            error_response: Error response
-        """
-        logger.error(f"Session error from {subscription_id}: {error_response.error_type} - {error_response.error_message}")
-
-        # Send error message via WebSocket if needed
-        if self.websocket_handler and hasattr(self.websocket_handler, 'send_message'):
-            error_message = {
-                'type': 'sessionError',
-                'payload': {
-                    'subscriptionIdentifier': subscription_id,
-                    'errorType': error_response.error_type,
-                    'errorMessage': error_response.error_message,
-                    'timestamp': error_response.timestamp
-                }
-            }
-
-            try:
-                serialized = serialize_outgoing_message(error_message)
-                await self.websocket_handler.send_message(serialized)
-            except Exception as e:
-                logger.error(f"Failed to send error message: {e}")
-
-    def get_session_stats(self) -> Dict[str, Any]:
-        """
-        Get statistics about active sessions.
-
-        Returns:
-            Dictionary with session statistics
-        """
-        return {
-            'active_sessions': self.session_manager.get_session_count(),
-            'max_sessions': self.session_manager.max_concurrent_sessions,
-            'subscriptions': list(self.active_subscriptions.keys())
-        }
-
-    async def handle_progression_stage(self, message) -> bool:
-        """
-        Handle setProgressionStage message.
-
-        Args:
-            message: SetProgressionStageMessage
-
-        Returns:
-            True if successful
-        """
-        try:
-            # For now, just update worker state for compatibility
-            # In future phases, this could be forwarded to session processes
-            worker_state.set_progression_stage(
-                message.payload.displayIdentifier,
-                message.payload.progressionStage
-            )
-            return True
-        except Exception as e:
-            logger.error(f"Error handling progression stage: {e}", exc_info=True)
-            return False
-
diff --git a/core/communication/websocket.py b/core/communication/websocket.py
index 749b3b9..e53096a 100644
--- a/core/communication/websocket.py
+++ b/core/communication/websocket.py
@@ -24,7 +24,6 @@ from .state import worker_state, SystemMetrics
 from ..models import ModelManager
 from ..streaming.manager import shared_stream_manager
 from ..tracking.integration import TrackingPipelineIntegration
-from .session_integration import SessionWebSocketIntegration
 
 logger = logging.getLogger(__name__)
 
@@ -49,9 +48,6 @@ class WebSocketHandler:
         self._heartbeat_count = 0
         self._last_processed_models: set = set()  # Cache of last processed model IDs
 
-        # Initialize session integration
-        self.session_integration = SessionWebSocketIntegration(self)
-
     async def handle_connection(self) -> None:
         """
         Main connection handler that manages the WebSocket lifecycle.
@@ -70,16 +66,14 @@ class WebSocketHandler:
             # Send immediate heartbeat to show connection is alive
             await self._send_immediate_heartbeat()
 
-            # Start session integration
-            await self.session_integration.start()
-
-            # Start background tasks - stream processing now handled by session workers
+            # Start background tasks (matching original architecture)
+            stream_task = asyncio.create_task(self._process_streams())
             heartbeat_task = asyncio.create_task(self._send_heartbeat())
             message_task = asyncio.create_task(self._handle_messages())
 
-            logger.info(f"WebSocket background tasks started for {client_info} (heartbeat + message handler)")
+            logger.info(f"WebSocket background tasks started for {client_info} (stream + heartbeat + message handler)")
 
-            # Wait for heartbeat and message tasks
+            # Wait for heartbeat and message tasks (stream runs independently)
             await asyncio.gather(heartbeat_task, message_task)
 
         except Exception as e:
@@ -93,11 +87,6 @@ class WebSocketHandler:
                     await stream_task
                 except asyncio.CancelledError:
                     logger.debug(f"Stream task cancelled for {client_info}")
-
-            # Stop session integration
-            if hasattr(self, 'session_integration'):
-                await self.session_integration.stop()
-
             await self._cleanup()
 
     async def _send_immediate_heartbeat(self) -> None:
@@ -191,11 +180,11 @@ class WebSocketHandler:
 
         try:
             if message_type == MessageTypes.SET_SUBSCRIPTION_LIST:
-                await self.session_integration.handle_set_subscription_list(message)
+                await self._handle_set_subscription_list(message)
             elif message_type == MessageTypes.SET_SESSION_ID:
-                await self.session_integration.handle_set_session_id(message)
+                await self._handle_set_session_id(message)
             elif message_type == MessageTypes.SET_PROGRESSION_STAGE:
-                await self.session_integration.handle_progression_stage(message)
+                await self._handle_set_progression_stage(message)
             elif message_type == MessageTypes.REQUEST_STATE:
                 await self._handle_request_state(message)
             elif message_type == MessageTypes.PATCH_SESSION_RESULT:
@@ -308,31 +297,31 @@ class WebSocketHandler:
     async def _reconcile_subscriptions_with_tracking(self, target_subscriptions) -> dict:
         """Reconcile subscriptions with tracking integration."""
         try:
-            # First, we need to create tracking integrations for each unique model
+            # Create separate tracking integrations for each subscription (camera isolation)
             tracking_integrations = {}
 
             for subscription_payload in target_subscriptions:
+                subscription_id = subscription_payload['subscriptionIdentifier']
                 model_id = subscription_payload['modelId']
 
-                # Create tracking integration if not already created
-                if model_id not in tracking_integrations:
-                    # Get pipeline configuration for this model
-                    pipeline_parser = model_manager.get_pipeline_config(model_id)
-                    if pipeline_parser:
-                        # Create tracking integration with message sender
-                        tracking_integration = TrackingPipelineIntegration(
-                            pipeline_parser, model_manager, model_id, self._send_message
-                        )
+                # Create separate tracking integration per subscription for camera isolation
+                # Get pipeline configuration for this model
+                pipeline_parser = model_manager.get_pipeline_config(model_id)
+                if pipeline_parser:
+                    # Create tracking integration with message sender (separate instance per camera)
+                    tracking_integration = TrackingPipelineIntegration(
+                        pipeline_parser, model_manager, model_id, self._send_message
+                    )
 
-                        # Initialize tracking model
-                        success = await tracking_integration.initialize_tracking_model()
-                        if success:
-                            tracking_integrations[model_id] = tracking_integration
-                            logger.info(f"[Tracking] Created tracking integration for model {model_id}")
-                        else:
-                            logger.warning(f"[Tracking] Failed to initialize tracking for model {model_id}")
+                    # Initialize tracking model
+                    success = await tracking_integration.initialize_tracking_model()
+                    if success:
+                        tracking_integrations[subscription_id] = tracking_integration
+                        logger.info(f"[Tracking] Created isolated tracking integration for subscription {subscription_id} (model {model_id})")
                     else:
-                        logger.warning(f"[Tracking] No pipeline config found for model {model_id}")
+                        logger.warning(f"[Tracking] Failed to initialize tracking for subscription {subscription_id} (model {model_id})")
+                else:
+                    logger.warning(f"[Tracking] No pipeline config found for model {model_id} in subscription {subscription_id}")
 
             # Now reconcile with StreamManager, adding tracking integrations
             current_subscription_ids = set()
@@ -388,8 +377,10 @@ class WebSocketHandler:
             camera_id = subscription_id.split(';')[-1]
             model_id = payload['modelId']
 
-            # Get tracking integration for this model
-            tracking_integration = tracking_integrations.get(model_id)
+            logger.info(f"[SUBSCRIPTION_MAPPING] subscription_id='{subscription_id}' → camera_id='{camera_id}'")
+
+            # Get tracking integration for this subscription (camera-isolated)
+            tracking_integration = tracking_integrations.get(subscription_id)
 
             # Extract crop coordinates if present
             crop_coords = None
@@ -421,7 +412,7 @@ class WebSocketHandler:
             )
 
             if success and tracking_integration:
-                logger.info(f"[Tracking] Subscription {subscription_id} configured with tracking for model {model_id}")
+                logger.info(f"[Tracking] Subscription {subscription_id} configured with isolated tracking for model {model_id}")
 
             return success
 
@@ -548,7 +539,7 @@ class WebSocketHandler:
     async def _handle_set_session_id(self, message: SetSessionIdMessage) -> None:
         """Handle setSessionId message."""
         display_identifier = message.payload.displayIdentifier
-        session_id = message.payload.sessionId
+        session_id = str(message.payload.sessionId) if message.payload.sessionId is not None else None
 
         logger.info(f"[RX Processing] setSessionId for display {display_identifier}: {session_id}")
 
@@ -558,10 +549,6 @@ class WebSocketHandler:
         # Update tracking integrations with session ID
         shared_stream_manager.set_session_id(display_identifier, session_id)
 
-        # Save snapshot image after getting sessionId
-        if session_id:
-            await self._save_snapshot(display_identifier, session_id)
-
     async def _handle_set_progression_stage(self, message: SetProgressionStageMessage) -> None:
         """Handle setProgressionStage message."""
         display_identifier = message.payload.displayIdentifier
@@ -577,6 +564,10 @@ class WebSocketHandler:
         if session_id:
             shared_stream_manager.set_progression_stage(session_id, stage)
 
+        # Save snapshot image when progression stage is car_fueling
+        if stage == 'car_fueling' and session_id:
+            await self._save_snapshot(display_identifier, session_id)
+
         # If stage indicates session is cleared/finished, clear from tracking
         if stage in ['finished', 'cleared', 'idle']:
             # Get session ID for this display and clear it
@@ -630,108 +621,31 @@ class WebSocketHandler:
             logger.error(f"Failed to send WebSocket message: {e}")
             raise
 
-    async def send_message(self, message) -> None:
-        """Public method to send messages (used by session integration)."""
-        await self._send_message(message)
-
-    # DEPRECATED: Stream processing is now handled directly by session worker processes
     async def _process_streams(self) -> None:
         """
-        DEPRECATED: Stream processing task that handles frame processing and detection.
-        Stream processing is now integrated directly into session worker processes.
+        Stream processing task that handles frame processing and detection.
+        This is a placeholder for Phase 2 - currently just logs that it's running.
         """
-        logger.info("DEPRECATED: Stream processing task - now handled by session workers")
-        return  # Exit immediately - no longer needed
-
-        # OLD CODE (disabled):
         logger.info("Stream processing task started")
         try:
             while self.connected:
                 # Get current subscriptions
                 subscriptions = worker_state.get_all_subscriptions()
 
-                if not subscriptions:
-                    await asyncio.sleep(0.5)
-                    continue
-
-                # Process frames for each subscription
-                for subscription in subscriptions:
-                    await self._process_subscription_frames(subscription)
+                # TODO: Phase 2 - Add actual frame processing logic here
+                # This will include:
+                # - Frame reading from RTSP/HTTP streams
+                # - Model inference using loaded pipelines
+                # - Detection result sending via WebSocket
 
                 # Sleep to prevent excessive CPU usage (similar to old poll_interval)
-                await asyncio.sleep(0.25)  # 250ms polling interval
+                await asyncio.sleep(0.1)  # 100ms polling interval
 
         except asyncio.CancelledError:
             logger.info("Stream processing task cancelled")
         except Exception as e:
             logger.error(f"Error in stream processing: {e}", exc_info=True)
 
-    async def _process_subscription_frames(self, subscription) -> None:
-        """
-        Process frames for a single subscription by getting frames from stream manager
-        and forwarding them to the appropriate session worker.
-        """
-        try:
-            subscription_id = subscription.subscriptionIdentifier
-
-            # Get the latest frame from the stream manager
-            frame_data = await self._get_frame_from_stream_manager(subscription)
-
-            if frame_data and frame_data['frame'] is not None:
-                # Extract display identifier (format: "test1;Dispenser Camera 1")
-                display_id = subscription_id.split(';')[-1] if ';' in subscription_id else subscription_id
-
-                # Forward frame to session worker via session integration
-                success = await self.session_integration.process_frame(
-                    subscription_id=subscription_id,
-                    frame=frame_data['frame'],
-                    display_id=display_id,
-                    timestamp=frame_data.get('timestamp', asyncio.get_event_loop().time())
-                )
-
-                if success:
-                    logger.debug(f"[Frame Processing] Sent frame to session worker for {subscription_id}")
-                else:
-                    logger.warning(f"[Frame Processing] Failed to send frame to session worker for {subscription_id}")
-
-        except Exception as e:
-            logger.error(f"Error processing frames for {subscription.subscriptionIdentifier}: {e}")
-
-    async def _get_frame_from_stream_manager(self, subscription) -> dict:
-        """
-        Get the latest frame from the stream manager for a subscription using existing API.
-        """
-        try:
-            subscription_id = subscription.subscriptionIdentifier
-
-            # Use existing stream manager API to check if frame is available
-            if not shared_stream_manager.has_frame(subscription_id):
-                # Stream should already be started by session integration
-                return {'frame': None, 'timestamp': None}
-
-            # Get frame using existing API with crop coordinates if available
-            crop_coords = None
-            if hasattr(subscription, 'cropX1') and subscription.cropX1 is not None:
-                crop_coords = (
-                    subscription.cropX1, subscription.cropY1,
-                    subscription.cropX2, subscription.cropY2
-                )
-
-            # Use existing get_frame method
-            frame = shared_stream_manager.get_frame(subscription_id, crop_coords)
-            if frame is not None:
-                return {
-                    'frame': frame,
-                    'timestamp': asyncio.get_event_loop().time()
-                }
-
-            return {'frame': None, 'timestamp': None}
-
-        except Exception as e:
-            logger.error(f"Error getting frame from stream manager for {subscription.subscriptionIdentifier}: {e}")
-            return {'frame': None, 'timestamp': None}
-
-
     async def _cleanup(self) -> None:
         """Clean up resources when connection closes."""
         logger.info("Cleaning up WebSocket connection")
diff --git a/core/detection/branches.py b/core/detection/branches.py
index 4639781..247c5f8 100644
--- a/core/detection/branches.py
+++ b/core/detection/branches.py
@@ -438,22 +438,11 @@ class BranchProcessor:
                        f"({input_frame.shape[1]}x{input_frame.shape[0]}) with confidence={min_confidence}")
 
 
-            # Determine model type and use appropriate calling method (like ML engineer's approach)
+            # Use .predict() method for both detection and classification models
             inference_start = time.time()
-
-            # Check if this is a classification model based on filename or model structure
-            is_classification = 'cls' in branch_id.lower() or 'classify' in branch_id.lower()
-
-            if is_classification:
-                # Use .predict() method for classification models (like ML engineer's classification_test.py)
-                detection_results = model.model.predict(source=input_frame, verbose=False)
-                logger.info(f"[INFERENCE DONE] {branch_id}: Classification completed in {time.time() - inference_start:.3f}s using .predict()")
-            else:
-                # Use direct model call for detection models (like ML engineer's detection_test.py)
-                detection_results = model.model(input_frame, conf=min_confidence, verbose=False)
-                logger.info(f"[INFERENCE DONE] {branch_id}: Detection completed in {time.time() - inference_start:.3f}s using direct call")
-
+            detection_results = model.model.predict(input_frame, conf=min_confidence, verbose=False)
             inference_time = time.time() - inference_start
+            logger.info(f"[INFERENCE DONE] {branch_id}: Predict completed in {inference_time:.3f}s using .predict() method")
 
             # Initialize branch_detections outside the conditional
             branch_detections = []
@@ -659,11 +648,17 @@ class BranchProcessor:
             # Format key with context
             key = action.params['key'].format(**context)
 
-            # Get image format parameters
+            # Convert image to bytes
             import cv2
             image_format = action.params.get('format', 'jpeg')
             quality = action.params.get('quality', 90)
 
+            if image_format.lower() == 'jpeg':
+                encode_param = [cv2.IMWRITE_JPEG_QUALITY, quality]
+                _, image_bytes = cv2.imencode('.jpg', image_to_save, encode_param)
+            else:
+                _, image_bytes = cv2.imencode('.png', image_to_save)
+
             # Save to Redis synchronously using a sync Redis client
             try:
                 import redis
diff --git a/core/detection/pipeline.py b/core/detection/pipeline.py
index ebc39e0..d395f3a 100644
--- a/core/detection/pipeline.py
+++ b/core/detection/pipeline.py
@@ -58,12 +58,16 @@ class DetectionPipeline:
         # Pipeline configuration
         self.pipeline_config = pipeline_parser.pipeline_config
 
-        # SessionId to subscriptionIdentifier mapping (ISOLATED per session process)
+        # SessionId to subscriptionIdentifier mapping
         self.session_to_subscription = {}
 
-        # SessionId to processing results mapping (ISOLATED per session process)
+        # SessionId to processing results mapping (for combining with license plate results)
         self.session_processing_results = {}
 
+        # Field mappings from parallelActions (e.g., {"car_brand": "{car_brand_cls_v3.brand}"})
+        self.field_mappings = {}
+        self._parse_field_mappings()
+
         # Statistics
         self.stats = {
             'detections_processed': 0,
@@ -72,8 +76,26 @@ class DetectionPipeline:
             'total_processing_time': 0.0
         }
 
-        logger.info(f"DetectionPipeline initialized for model {model_id} with ISOLATED state (no shared mappings or cache)")
-        logger.info(f"Pipeline instance ID: {id(self)} - unique per session process")
+        logger.info("DetectionPipeline initialized")
+
+    def _parse_field_mappings(self):
+        """
+        Parse field mappings from parallelActions.postgresql_update_combined.fields.
+        Extracts mappings like {"car_brand": "{car_brand_cls_v3.brand}"} for dynamic field resolution.
+        """
+        try:
+            if not self.pipeline_config or not hasattr(self.pipeline_config, 'parallel_actions'):
+                return
+
+            for action in self.pipeline_config.parallel_actions:
+                if action.type.value == 'postgresql_update_combined':
+                    fields = action.params.get('fields', {})
+                    self.field_mappings = fields
+                    logger.info(f"[FIELD MAPPINGS] Parsed from pipeline config: {self.field_mappings}")
+                    break
+
+        except Exception as e:
+            logger.error(f"Error parsing field mappings: {e}", exc_info=True)
 
     async def initialize(self) -> bool:
         """
@@ -134,49 +156,76 @@ class DetectionPipeline:
 
     async def _initialize_detection_model(self) -> bool:
         """
-        Load and initialize the main detection model from pipeline.json configuration.
+        Load and initialize the main detection model.
 
         Returns:
             True if successful, False otherwise
         """
         try:
             if not self.pipeline_config:
-                logger.error("No pipeline configuration found - cannot initialize detection model")
+                logger.warning("No pipeline configuration found")
                 return False
 
             model_file = getattr(self.pipeline_config, 'model_file', None)
             model_id = getattr(self.pipeline_config, 'model_id', None)
-            min_confidence = getattr(self.pipeline_config, 'min_confidence', 0.6)
-            trigger_classes = getattr(self.pipeline_config, 'trigger_classes', [])
-            crop = getattr(self.pipeline_config, 'crop', False)
 
             if not model_file:
-                logger.error("No detection model file specified in pipeline configuration")
+                logger.warning("No detection model file specified")
                 return False
 
-            # Log complete pipeline configuration for main detection model
-            logger.info(f"[MAIN MODEL CONFIG] Initializing from pipeline.json:")
-            logger.info(f"[MAIN MODEL CONFIG]   modelId: {model_id}")
-            logger.info(f"[MAIN MODEL CONFIG]   modelFile: {model_file}")
-            logger.info(f"[MAIN MODEL CONFIG]   minConfidence: {min_confidence}")
-            logger.info(f"[MAIN MODEL CONFIG]   triggerClasses: {trigger_classes}")
-            logger.info(f"[MAIN MODEL CONFIG]   crop: {crop}")
-
-            # Load detection model using model manager
-            logger.info(f"[MAIN MODEL LOADING] Loading {model_file} from model directory {self.model_id}")
+            # Load detection model
+            logger.info(f"Loading detection model: {model_id} ({model_file})")
             self.detection_model = self.model_manager.get_yolo_model(self.model_id, model_file)
             if not self.detection_model:
-                logger.error(f"[MAIN MODEL ERROR] Failed to load detection model {model_file} from model {self.model_id}")
+                logger.error(f"Failed to load detection model {model_file} from model {self.model_id}")
                 return False
 
             self.detection_model_id = model_id
-            logger.info(f"[MAIN MODEL SUCCESS] Detection model {model_id} ({model_file}) loaded successfully")
+            logger.info(f"Detection model {model_id} loaded successfully")
             return True
 
         except Exception as e:
             logger.error(f"Error initializing detection model: {e}", exc_info=True)
             return False
 
+    def _extract_fields_from_branches(self, branch_results: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Extract fields dynamically from branch results using field mappings.
+
+        Args:
+            branch_results: Dictionary of branch execution results
+
+        Returns:
+            Dictionary with extracted field values (e.g., {"car_brand": "Honda", "body_type": "Sedan"})
+        """
+        extracted = {}
+
+        try:
+            for db_field_name, template in self.field_mappings.items():
+                # Parse template like "{car_brand_cls_v3.brand}" -> branch_id="car_brand_cls_v3", field="brand"
+                if template.startswith('{') and template.endswith('}'):
+                    var_name = template[1:-1]
+                    if '.' in var_name:
+                        branch_id, field_name = var_name.split('.', 1)
+
+                        # Look up value in branch_results
+                        if branch_id in branch_results:
+                            branch_data = branch_results[branch_id]
+                            if isinstance(branch_data, dict) and 'result' in branch_data:
+                                result_data = branch_data['result']
+                                if isinstance(result_data, dict) and field_name in result_data:
+                                    extracted[field_name] = result_data[field_name]
+                                    logger.debug(f"[DYNAMIC EXTRACT] {field_name}={result_data[field_name]} from branch {branch_id}")
+                                else:
+                                    logger.debug(f"[DYNAMIC EXTRACT] Field '{field_name}' not found in branch {branch_id}")
+                        else:
+                            logger.debug(f"[DYNAMIC EXTRACT] Branch '{branch_id}' not in results")
+
+        except Exception as e:
+            logger.error(f"Error extracting fields from branches: {e}", exc_info=True)
+
+        return extracted
+
     async def _on_license_plate_result(self, session_id: str, license_data: Dict[str, Any]):
         """
         Callback for handling license plate results from LPR service.
@@ -284,12 +333,12 @@ class DetectionPipeline:
                 branch_results = self.session_processing_results[session_id_for_lookup]
                 logger.info(f"[LICENSE PLATE] Retrieved processing results for session {session_id_for_lookup}")
 
-                if 'car_brand_cls_v2' in branch_results:
-                    brand_result = branch_results['car_brand_cls_v2'].get('result', {})
-                    car_brand = brand_result.get('brand')
-                if 'car_bodytype_cls_v1' in branch_results:
-                    bodytype_result = branch_results['car_bodytype_cls_v1'].get('result', {})
-                    body_type = bodytype_result.get('body_type')
+                # Extract fields dynamically using field mappings from pipeline config
+                extracted_fields = self._extract_fields_from_branches(branch_results)
+                car_brand = extracted_fields.get('brand')
+                body_type = extracted_fields.get('body_type')
+
+                logger.info(f"[LICENSE PLATE] Extracted fields: brand={car_brand}, body_type={body_type}")
 
                 # Clean up stored results after use
                 del self.session_processing_results[session_id_for_lookup]
@@ -364,76 +413,6 @@ class DetectionPipeline:
         except Exception as e:
             logger.error(f"Error sending initial detection imageDetection message: {e}", exc_info=True)
 
-    async def _send_processing_results_message(self, subscription_id: str, branch_results: Dict[str, Any], session_id: Optional[str] = None):
-        """
-        Send imageDetection message immediately with processing results, regardless of completeness.
-        Sends even if no results, partial results, or complete results are available.
-
-        Args:
-            subscription_id: Subscription identifier to send message to
-            branch_results: Branch processing results (may be empty or partial)
-            session_id: Session identifier for logging
-        """
-        try:
-            if not self.message_sender:
-                logger.warning("No message sender configured, cannot send imageDetection")
-                return
-
-            # Import here to avoid circular imports
-            from ..communication.models import ImageDetectionMessage, DetectionData
-
-            # Extract classification results from branch results
-            car_brand = None
-            body_type = None
-
-            if branch_results:
-                # Extract car brand from car_brand_cls_v2 results
-                if 'car_brand_cls_v2' in branch_results:
-                    brand_result = branch_results['car_brand_cls_v2'].get('result', {})
-                    car_brand = brand_result.get('brand')
-
-                # Extract body type from car_bodytype_cls_v1 results
-                if 'car_bodytype_cls_v1' in branch_results:
-                    bodytype_result = branch_results['car_bodytype_cls_v1'].get('result', {})
-                    body_type = bodytype_result.get('body_type')
-
-            # Create detection data with available results (fields can be None)
-            detection_data_obj = DetectionData(
-                detection={
-                    "carBrand": car_brand,
-                    "carModel": None,  # Not implemented yet
-                    "bodyType": body_type,
-                    "licensePlateText": None,  # Will be updated later if available
-                    "licensePlateConfidence": None
-                },
-                modelId=self.model_id,
-                modelName=self.pipeline_parser.pipeline_config.model_id if self.pipeline_parser.pipeline_config else "detection_model"
-            )
-
-            # Create imageDetection message
-            detection_message = ImageDetectionMessage(
-                subscriptionIdentifier=subscription_id,
-                data=detection_data_obj
-            )
-
-            # Send message
-            await self.message_sender(detection_message)
-
-            # Log what was sent
-            result_summary = []
-            if car_brand:
-                result_summary.append(f"brand='{car_brand}'")
-            if body_type:
-                result_summary.append(f"bodyType='{body_type}'")
-            if not result_summary:
-                result_summary.append("no classification results")
-
-            logger.info(f"[PROCESSING COMPLETE] Sent imageDetection with {', '.join(result_summary)} to '{subscription_id}'"
-                       f"{f' (session {session_id})' if session_id else ''}")
-
-        except Exception as e:
-            logger.error(f"Error sending processing results imageDetection message: {e}", exc_info=True)
-
     async def execute_detection_phase(self,
                                     frame: np.ndarray,
                                     display_id: str,
@@ -474,13 +453,10 @@ class DetectionPipeline:
                 'timestamp_ms': int(time.time() * 1000)
             }
 
-            # Run inference using direct model call (like ML engineer's approach)
-            # Use minConfidence from pipeline.json configuration
-            model_confidence = getattr(self.pipeline_config, 'min_confidence', 0.6)
-            logger.info(f"[DETECTION PHASE] Running {self.pipeline_config.model_id} with conf={model_confidence} (from pipeline.json)")
-            detection_results = self.detection_model.model(
+            # Run inference on single snapshot using .predict() method
+            detection_results = self.detection_model.model.predict(
                 frame,
-                conf=model_confidence,
+                conf=getattr(self.pipeline_config, 'min_confidence', 0.6),
                 verbose=False
             )
 
@@ -492,7 +468,7 @@ class DetectionPipeline:
                 result_obj = detection_results[0]
                 trigger_classes = getattr(self.pipeline_config, 'trigger_classes', [])
 
-                # Handle direct model call results which have .boxes for detection models
+                # Handle .predict() results which have .boxes for detection models
                 if hasattr(result_obj, 'boxes') and result_obj.boxes is not None:
                     logger.info(f"[DETECTION PHASE] Found {len(result_obj.boxes)} raw detections from {getattr(self.pipeline_config, 'model_id', 'unknown')}")
 
@@ -601,13 +577,10 @@ class DetectionPipeline:
 
             # If no detected_regions provided, re-run detection to get them
             if not detected_regions:
-                # Use direct model call for detection (like ML engineer's approach)
-                # Use minConfidence from pipeline.json configuration
-                model_confidence = getattr(self.pipeline_config, 'min_confidence', 0.6)
-                logger.info(f"[PROCESSING PHASE] Re-running {self.pipeline_config.model_id} with conf={model_confidence} (from pipeline.json)")
-                detection_results = self.detection_model.model(
+                # Use .predict() method for detection
+                detection_results = self.detection_model.model.predict(
                     frame,
-                    conf=model_confidence,
+                    conf=getattr(self.pipeline_config, 'min_confidence', 0.6),
                     verbose=False
                 )
 
@@ -681,31 +654,19 @@ class DetectionPipeline:
                 )
                 result['actions_executed'].extend(executed_parallel_actions)
 
-            # Send imageDetection message immediately with available results
-            await self._send_processing_results_message(subscription_id, result['branch_results'], session_id)
-
-            # Store processing results for later combination with license plate data if needed
+            # Store processing results for later combination with license plate data
             if result['branch_results'] and session_id:
                 self.session_processing_results[session_id] = result['branch_results']
-                logger.info(f"[PROCESSING RESULTS] Stored results for session {session_id} for potential license plate combination")
+                logger.info(f"[PROCESSING RESULTS] Stored results for session {session_id} for later combination")
 
             logger.info(f"Processing phase completed for session {session_id}: "
-                       f"status={result.get('status', 'unknown')}, "
-                       f"branches={len(result['branch_results'])}, "
-                       f"actions={len(result['actions_executed'])}, "
-                       f"processing_time={result.get('processing_time', 0):.3f}s")
+                       f"{len(result['branch_results'])} branches, {len(result['actions_executed'])} actions")
 
         except Exception as e:
             logger.error(f"Error in processing phase: {e}", exc_info=True)
             result['status'] = 'error'
             result['message'] = str(e)
 
-            # Even if there was an error, send imageDetection message with whatever results we have
-            try:
-                await self._send_processing_results_message(subscription_id, result['branch_results'], session_id)
-            except Exception as send_error:
-                logger.error(f"Failed to send imageDetection message after processing error: {send_error}")
-
         result['processing_time'] = time.time() - start_time
         return result
 
@@ -760,13 +721,10 @@ class DetectionPipeline:
             }
 
 
-            # Run inference using direct model call (like ML engineer's approach)
-            # Use minConfidence from pipeline.json configuration
-            model_confidence = getattr(self.pipeline_config, 'min_confidence', 0.6)
-            logger.info(f"[PIPELINE EXECUTE] Running {self.pipeline_config.model_id} with conf={model_confidence} (from pipeline.json)")
-            detection_results = self.detection_model.model(
+            # Run inference on single snapshot using .predict() method
+            detection_results = self.detection_model.model.predict(
                 frame,
-                conf=model_confidence,
+                conf=getattr(self.pipeline_config, 'min_confidence', 0.6),
                 verbose=False
             )
 
@@ -778,7 +736,7 @@ class DetectionPipeline:
                 result_obj = detection_results[0]
                 trigger_classes = getattr(self.pipeline_config, 'trigger_classes', [])
 
-                # Handle direct model call results which have .boxes for detection models
+                # Handle .predict() results which have .boxes for detection models
                 if hasattr(result_obj, 'boxes') and result_obj.boxes is not None:
                     logger.info(f"[PIPELINE RAW] Found {len(result_obj.boxes)} raw detections from {getattr(self.pipeline_config, 'model_id', 'unknown')}")
 
@@ -1061,16 +1019,11 @@ class DetectionPipeline:
             wait_for_branches = action.params.get('waitForBranches', [])
             branch_results = context.get('branch_results', {})
 
-            # Log which branches are available vs. expected
-            missing_branches = [branch_id for branch_id in wait_for_branches if branch_id not in branch_results]
-            available_branches = [branch_id for branch_id in wait_for_branches if branch_id in branch_results]
-
-            if missing_branches:
-                logger.warning(f"Some branches missing for database update - available: {available_branches}, missing: {missing_branches}")
-            else:
-                logger.info(f"All expected branches available for database update: {available_branches}")
-
-            # Continue with update using whatever results are available (don't fail on missing branches)
+            # Check if all required branches have completed
+            for branch_id in wait_for_branches:
+                if branch_id not in branch_results:
+                    logger.warning(f"Branch {branch_id} result not available for database update")
+                    return {'status': 'error', 'message': f'Missing branch result: {branch_id}'}
 
             # Prepare fields for database update
             table = action.params.get('table', 'car_frontal_info')
@@ -1089,7 +1042,7 @@ class DetectionPipeline:
                     logger.warning(f"Failed to resolve field {field_name}: {e}")
                     resolved_fields[field_name] = None
 
-            # Execute database update with available data
+            # Execute database update
             success = self.db_manager.execute_update(
                 table=table,
                 key_field=key_field,
@@ -1097,26 +1050,9 @@ class DetectionPipeline:
                 fields=resolved_fields
             )
 
-            # Log the update result with details about what data was available
-            non_null_fields = {k: v for k, v in resolved_fields.items() if v is not None}
-            null_fields = [k for k, v in resolved_fields.items() if v is None]
-
             if success:
-                logger.info(f"[DATABASE UPDATE] Success for session {key_value}: "
-                           f"updated {len(non_null_fields)} fields {list(non_null_fields.keys())}"
-                           f"{f', {len(null_fields)} null fields {null_fields}' if null_fields else ''}")
-                return {
-                    'status': 'success',
-                    'table': table,
-                    'key': f'{key_field}={key_value}',
-                    'fields': resolved_fields,
-                    'updated_fields': non_null_fields,
-                    'null_fields': null_fields,
-                    'available_branches': available_branches,
-                    'missing_branches': missing_branches
-                }
+                return {'status': 'success', 'table': table, 'key': f'{key_field}={key_value}', 'fields': resolved_fields}
             else:
-                logger.error(f"[DATABASE UPDATE] Failed for session {key_value}")
                 return {'status': 'error', 'message': 'Database update failed'}
 
         except Exception as e:
@@ -1128,7 +1064,7 @@ class DetectionPipeline:
         Resolve field template using branch results and context.
 
         Args:
-            template: Template string like "{car_brand_cls_v2.brand}"
+            template: Template string like "{car_brand_cls_v3.brand}"
             branch_results: Dictionary of branch execution results
             context: Detection context
 
@@ -1140,7 +1076,7 @@ class DetectionPipeline:
             if template.startswith('{') and template.endswith('}'):
                 var_name = template[1:-1]
 
-                # Check for branch result reference (e.g., "car_brand_cls_v2.brand")
+                # Check for branch result reference (e.g., "car_brand_cls_v3.brand")
                 if '.' in var_name:
                     branch_id, field_name = var_name.split('.', 1)
                     if branch_id in branch_results:
@@ -1186,17 +1122,10 @@ class DetectionPipeline:
                 logger.warning("No session_id in context for processing results")
                 return
 
-            # Extract car brand from car_brand_cls_v2 results
-            car_brand = None
-            if 'car_brand_cls_v2' in branch_results:
-                brand_result = branch_results['car_brand_cls_v2'].get('result', {})
-                car_brand = brand_result.get('brand')
-
-            # Extract body type from car_bodytype_cls_v1 results
-            body_type = None
-            if 'car_bodytype_cls_v1' in branch_results:
-                bodytype_result = branch_results['car_bodytype_cls_v1'].get('result', {})
-                body_type = bodytype_result.get('body_type')
+            # Extract fields dynamically using field mappings from pipeline config
+            extracted_fields = self._extract_fields_from_branches(branch_results)
+            car_brand = extracted_fields.get('brand')
+            body_type = extracted_fields.get('body_type')
 
             logger.info(f"[PROCESSING RESULTS] Completed for session {session_id}: "
                        f"brand={car_brand}, bodyType={body_type}")
diff --git a/core/logging/__init__.py b/core/logging/__init__.py
deleted file mode 100644
index 9d267b7..0000000
--- a/core/logging/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-Per-Session Logging Module
-"""
\ No newline at end of file
diff --git a/core/logging/session_logger.py b/core/logging/session_logger.py
deleted file mode 100644
index cb641ae..0000000
--- a/core/logging/session_logger.py
+++ /dev/null
@@ -1,356 +0,0 @@
-"""
-Per-Session Logging Configuration and Management.
-Each session process gets its own dedicated log file with rotation support.
-"""
-
-import logging
-import logging.handlers
-import os
-import sys
-from pathlib import Path
-from typing import Optional
-from datetime import datetime
-import re
-
-
-class PerSessionLogger:
-    """
-    Per-session logging configuration that creates dedicated log files for each session.
-    Supports log rotation and structured logging with session context.
-    """
-
-    def __init__(
-        self,
-        session_id: str,
-        subscription_identifier: str,
-        log_dir: str = "logs",
-        max_size_mb: int = 100,
-        backup_count: int = 5,
-        log_level: int = logging.INFO,
-        detection_mode: bool = True
-    ):
-        """
-        Initialize per-session logger.
-
-        Args:
-            session_id: Unique session identifier
-            subscription_identifier: Subscription identifier (contains camera info)
-            log_dir: Directory to store log files
-            max_size_mb: Maximum size of each log file in MB
-            backup_count: Number of backup files to keep
-            log_level: Logging level
-            detection_mode: If True, uses reduced verbosity for detection processes
-        """
-        self.session_id = session_id
-        self.subscription_identifier = subscription_identifier
-        self.log_dir = Path(log_dir)
-        self.max_size_mb = max_size_mb
-        self.backup_count = backup_count
-        self.log_level = log_level
-        self.detection_mode = detection_mode
-
-        # Ensure log directory exists
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-
-        # Generate clean filename from subscription identifier
-        self.log_filename = self._generate_log_filename()
-        self.log_filepath = self.log_dir / self.log_filename
-
-        # Create logger
-        self.logger = self._setup_logger()
-
-    def _generate_log_filename(self) -> str:
-        """
-        Generate a clean filename from subscription identifier.
-        Format: detector_worker_camera_{clean_subscription_id}.log
-
-        Returns:
-            Clean filename for the log file
-        """
-        # Clean subscription identifier for filename
-        # Replace problematic characters with underscores
-        clean_sub_id = re.sub(r'[^\w\-_.]', '_', self.subscription_identifier)
-
-        # Remove consecutive underscores
-        clean_sub_id = re.sub(r'_+', '_', clean_sub_id)
-
-        # Remove leading/trailing underscores
-        clean_sub_id = clean_sub_id.strip('_')
-
-        # Generate filename
-        filename = f"detector_worker_camera_{clean_sub_id}.log"
-
-        return filename
-
-    def _setup_logger(self) -> logging.Logger:
-        """
-        Setup logger with file handler and rotation.
-
-        Returns:
-            Configured logger instance
-        """
-        # Create logger with unique name
-        logger_name = f"session_worker_{self.session_id}"
-        logger = logging.getLogger(logger_name)
-
-        # Clear any existing handlers to avoid duplicates
-        logger.handlers.clear()
-
-        # Set logging level
-        logger.setLevel(self.log_level)
-
-        # Create formatter with session context
-        formatter = logging.Formatter(
-            fmt='%(asctime)s [%(levelname)s] %(name)s [Session: {session_id}] [Camera: {camera}]: %(message)s'.format(
-                session_id=self.session_id,
-                camera=self.subscription_identifier
-            ),
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
-
-        # Create rotating file handler
-        max_bytes = self.max_size_mb * 1024 * 1024  # Convert MB to bytes
-        file_handler = logging.handlers.RotatingFileHandler(
-            filename=self.log_filepath,
-            maxBytes=max_bytes,
-            backupCount=self.backup_count,
-            encoding='utf-8'
-        )
-        file_handler.setLevel(self.log_level)
-        file_handler.setFormatter(formatter)
-
-        # Create console handler for debugging (optional)
-        console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setLevel(logging.WARNING)  # Only warnings and errors to console
-        console_formatter = logging.Formatter(
-            fmt='[{session_id}] [%(levelname)s]: %(message)s'.format(
-                session_id=self.session_id
-            )
-        )
-        console_handler.setFormatter(console_formatter)
-
-        # Add handlers to logger
-        logger.addHandler(file_handler)
-        logger.addHandler(console_handler)
-
-        # Prevent propagation to root logger
-        logger.propagate = False
-
-        # Log initialization (reduced verbosity in detection mode)
-        if self.detection_mode:
-            logger.info(f"Session logger ready for {self.subscription_identifier}")
-        else:
-            logger.info(f"Per-session logger initialized")
-            logger.info(f"Log file: {self.log_filepath}")
-            logger.info(f"Session ID: {self.session_id}")
-            logger.info(f"Camera: {self.subscription_identifier}")
-            logger.info(f"Max size: {self.max_size_mb}MB, Backup count: {self.backup_count}")
-
-        return logger
-
-    def get_logger(self) -> logging.Logger:
-        """
-        Get the configured logger instance.
-
-        Returns:
-            Logger instance for this session
-        """
-        return self.logger
-
-    def log_session_start(self, process_id: int):
-        """
-        Log session start with process information.
-
-        Args:
-            process_id: Process ID of the session worker
-        """
-        if self.detection_mode:
-            self.logger.info(f"Session started - PID {process_id}")
-        else:
-            self.logger.info("=" * 60)
-            self.logger.info(f"SESSION STARTED")
-            self.logger.info(f"Process ID: {process_id}")
-            self.logger.info(f"Session ID: {self.session_id}")
-            self.logger.info(f"Camera: {self.subscription_identifier}")
-            self.logger.info(f"Timestamp: {datetime.now().isoformat()}")
-            self.logger.info("=" * 60)
-
-    def log_session_end(self):
-        """Log session end."""
-        self.logger.info("=" * 60)
-        self.logger.info(f"SESSION ENDED")
-        self.logger.info(f"Timestamp: {datetime.now().isoformat()}")
-        self.logger.info("=" * 60)
-
-    def log_model_loading(self, model_id: int, model_name: str, model_path: str):
-        """
-        Log model loading information.
-
-        Args:
-            model_id: Model ID
-            model_name: Model name
-            model_path: Path to the model
-        """
-        if self.detection_mode:
-            self.logger.info(f"Loading model {model_id}: {model_name}")
-        else:
-            self.logger.info("-" * 40)
-            self.logger.info(f"MODEL LOADING")
-            self.logger.info(f"Model ID: {model_id}")
-            self.logger.info(f"Model Name: {model_name}")
-            self.logger.info(f"Model Path: {model_path}")
-            self.logger.info("-" * 40)
-
-    def log_frame_processing(self, frame_count: int, processing_time: float, detections: int):
-        """
-        Log frame processing information.
-
-        Args:
-            frame_count: Current frame count
-            processing_time: Processing time in seconds
-            detections: Number of detections found
-        """
-        self.logger.debug(f"FRAME #{frame_count}: Processing time: {processing_time:.3f}s, Detections: {detections}")
-
-    def log_detection_result(self, detection_type: str, confidence: float, bbox: list):
-        """
-        Log detection result.
-
-        Args:
-            detection_type: Type of detection (e.g., "Car", "Frontal")
-            confidence: Detection confidence
-            bbox: Bounding box coordinates
-        """
-        self.logger.info(f"DETECTION: {detection_type} (conf: {confidence:.3f}) at {bbox}")
-
-    def log_database_operation(self, operation: str, session_id: str, success: bool):
-        """
-        Log database operation.
-
-        Args:
-            operation: Type of operation
-            session_id: Session ID used in database
-            success: Whether operation succeeded
-        """
-        status = "SUCCESS" if success else "FAILED"
-        self.logger.info(f"DATABASE {operation}: {status} (session: {session_id})")
-
-    def log_error(self, error_type: str, error_message: str, traceback_str: Optional[str] = None):
-        """
-        Log error with context.
-
-        Args:
-            error_type: Type of error
-            error_message: Error message
-            traceback_str: Optional traceback string
-        """
-        self.logger.error(f"ERROR [{error_type}]: {error_message}")
-        if traceback_str:
-            self.logger.error(f"Traceback:\n{traceback_str}")
-
-    def get_log_stats(self) -> dict:
-        """
-        Get logging statistics.
-
-        Returns:
-            Dictionary with logging statistics
-        """
-        try:
-            if self.log_filepath.exists():
-                stat = self.log_filepath.stat()
-                return {
-                    'log_file': str(self.log_filepath),
-                    'file_size_mb': round(stat.st_size / (1024 * 1024), 2),
-                    'created': datetime.fromtimestamp(stat.st_ctime).isoformat(),
-                    'modified': datetime.fromtimestamp(stat.st_mtime).isoformat(),
-                }
-            else:
-                return {'log_file': str(self.log_filepath), 'status': 'not_created'}
-        except Exception as e:
-            return {'log_file': str(self.log_filepath), 'error': str(e)}
-
-    def cleanup(self):
-        """Cleanup logger handlers."""
-        if hasattr(self, 'logger') and self.logger:
-            for handler in self.logger.handlers[:]:
-                handler.close()
-                self.logger.removeHandler(handler)
-
-
-class MainProcessLogger:
-    """
-    Logger configuration for the main FastAPI process.
-    Separate from session logs to avoid confusion.
-    """
-
-    def __init__(self, log_dir: str = "logs", max_size_mb: int = 50, backup_count: int = 3):
-        """
-        Initialize main process logger.
-
-        Args:
-            log_dir: Directory to store log files
-            max_size_mb: Maximum size of each log file in MB
-            backup_count: Number of backup files to keep
-        """
-        self.log_dir = Path(log_dir)
-        self.max_size_mb = max_size_mb
-        self.backup_count = backup_count
-
-        # Ensure log directory exists
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-
-        # Setup main process logger
-        self._setup_main_logger()
-
-    def _setup_main_logger(self):
-        """Setup main process logger."""
-        # Configure root logger
-        root_logger = logging.getLogger("detector_worker")
-
-        # Clear existing handlers
-        for handler in root_logger.handlers[:]:
-            root_logger.removeHandler(handler)
-
-        # Set level
-        root_logger.setLevel(logging.INFO)
-
-        # Create formatter
-        formatter = logging.Formatter(
-            fmt='%(asctime)s [%(levelname)s] %(name)s [MAIN]: %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
-
-        # Create rotating file handler for main process
-        max_bytes = self.max_size_mb * 1024 * 1024
-        main_log_path = self.log_dir / "detector_worker_main.log"
-        file_handler = logging.handlers.RotatingFileHandler(
-            filename=main_log_path,
-            maxBytes=max_bytes,
-            backupCount=self.backup_count,
-            encoding='utf-8'
-        )
-        file_handler.setLevel(logging.INFO)
-        file_handler.setFormatter(formatter)
-
-        # Create console handler
-        console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.INFO)
-        console_handler.setFormatter(formatter)
-
-        # Add handlers
-        root_logger.addHandler(file_handler)
-        root_logger.addHandler(console_handler)
-
-        # Log initialization
-        root_logger.info("Main process logger initialized")
-        root_logger.info(f"Main log file: {main_log_path}")
-
-
-def setup_main_process_logging(log_dir: str = "logs"):
-    """
-    Setup logging for the main FastAPI process.
-
-    Args:
-        log_dir: Directory to store log files
-    """
-    MainProcessLogger(log_dir=log_dir)
\ No newline at end of file
diff --git a/core/models/inference.py b/core/models/inference.py
index 33c653b..f96c0e8 100644
--- a/core/models/inference.py
+++ b/core/models/inference.py
@@ -34,7 +34,11 @@ class InferenceResult:
 
 
 class YOLOWrapper:
-    """Wrapper for YOLO models with per-instance isolation (no shared cache)"""
+    """Wrapper for YOLO models with caching and optimization"""
+
+    # Class-level model cache shared across all instances
+    _model_cache: Dict[str, Any] = {}
+    _cache_lock = Lock()
 
     def __init__(self, model_path: Path, model_id: str, device: Optional[str] = None):
         """
@@ -56,53 +60,48 @@ class YOLOWrapper:
 
         self.model = None
         self._class_names = []
+
+
         self._load_model()
 
         logger.info(f"Initialized YOLO wrapper for {model_id} on {self.device}")
 
     def _load_model(self) -> None:
-        """Load the YOLO model in isolation (no shared cache)"""
-        try:
-            from ultralytics import YOLO
+        """Load the YOLO model with caching"""
+        cache_key = str(self.model_path)
 
-            logger.debug(f"Loading YOLO model {self.model_id} from {self.model_path} (ISOLATED)")
+        with self._cache_lock:
+            # Check if model is already cached
+            if cache_key in self._model_cache:
+                logger.info(f"Loading model {self.model_id} from cache")
+                self.model = self._model_cache[cache_key]
+                self._extract_class_names()
+                return
 
-            # Load model directly without any caching
-            self.model = YOLO(str(self.model_path))
+            # Load model
+            try:
+                from ultralytics import YOLO
 
-            # Determine if this is a classification model based on filename or model structure
-            # Classification models typically have 'cls' in filename
-            is_classification = 'cls' in str(self.model_path).lower()
+                logger.info(f"Loading YOLO model from {self.model_path}")
+                self.model = YOLO(str(self.model_path))
 
-            # For classification models, create a separate instance with task parameter
-            if is_classification:
-                try:
-                    # Reload with classification task (like ML engineer's approach)
-                    self.model = YOLO(str(self.model_path), task="classify")
-                    logger.info(f"Loaded classification model {self.model_id} with task='classify' (ISOLATED)")
-                except Exception as e:
-                    logger.warning(f"Failed to load with task='classify', using default: {e}")
-                    # Fall back to regular loading
-                    self.model = YOLO(str(self.model_path))
-                    logger.info(f"Loaded model {self.model_id} with default task (ISOLATED)")
-            else:
-                logger.info(f"Loaded detection model {self.model_id} (ISOLATED)")
+                # Move model to device
+                if self.device == 'cuda' and torch.cuda.is_available():
+                    self.model.to('cuda')
+                    logger.info(f"Model {self.model_id} moved to GPU")
 
-            # Move model to device
-            if self.device == 'cuda' and torch.cuda.is_available():
-                self.model.to('cuda')
-                logger.info(f"Model {self.model_id} moved to GPU (ISOLATED)")
+                # Cache the model
+                self._model_cache[cache_key] = self.model
+                self._extract_class_names()
 
-            self._extract_class_names()
+                logger.info(f"Successfully loaded model {self.model_id}")
 
-            logger.debug(f"Successfully loaded model {self.model_id} in isolation - no shared cache!")
-
-        except ImportError:
-            logger.error("Ultralytics YOLO not installed. Install with: pip install ultralytics")
-            raise
-        except Exception as e:
-            logger.error(f"Failed to load YOLO model {self.model_id}: {str(e)}", exc_info=True)
-            raise
+            except ImportError:
+                logger.error("Ultralytics YOLO not installed. Install with: pip install ultralytics")
+                raise
+            except Exception as e:
+                logger.error(f"Failed to load YOLO model {self.model_id}: {str(e)}", exc_info=True)
+                raise
 
     def _extract_class_names(self) -> None:
         """Extract class names from the model"""
@@ -118,6 +117,7 @@ class YOLOWrapper:
             logger.error(f"Failed to extract class names: {str(e)}")
             self._class_names = {}
 
+
     def infer(
         self,
         image: np.ndarray,
@@ -144,7 +144,7 @@ class YOLOWrapper:
             import time
             start_time = time.time()
 
-            # Run inference using direct model call (like ML engineer's approach)
+            # Run inference
             results = self.model(
                 image,
                 conf=confidence_threshold,
@@ -225,55 +225,30 @@ class YOLOWrapper:
 
         return detections
 
+
     def track(
         self,
         image: np.ndarray,
         confidence_threshold: float = 0.5,
         trigger_classes: Optional[List[str]] = None,
-        persist: bool = True
+        persist: bool = True,
+        camera_id: Optional[str] = None
     ) -> InferenceResult:
         """
-        Run tracking on an image
+        Run detection (tracking will be handled by external tracker)
 
         Args:
             image: Input image as numpy array (BGR format)
             confidence_threshold: Minimum confidence for detections
             trigger_classes: List of class names to filter
-            persist: Whether to persist tracks across frames
+            persist: Ignored - tracking handled externally
+            camera_id: Ignored - tracking handled externally
 
         Returns:
-            InferenceResult containing detections with track IDs
+            InferenceResult containing detections (no track IDs from YOLO)
         """
-        if self.model is None:
-            raise RuntimeError(f"Model {self.model_id} not loaded")
-
-        try:
-            import time
-            start_time = time.time()
-
-            # Run tracking
-            results = self.model.track(
-                image,
-                conf=confidence_threshold,
-                persist=persist,
-                verbose=False
-            )
-
-            inference_time = time.time() - start_time
-
-            # Parse results
-            detections = self._parse_results(results[0], trigger_classes)
-
-            return InferenceResult(
-                detections=detections,
-                image_shape=(image.shape[0], image.shape[1]),
-                inference_time=inference_time,
-                model_id=self.model_id
-            )
-
-        except Exception as e:
-            logger.error(f"Tracking failed for model {self.model_id}: {str(e)}", exc_info=True)
-            raise
+        # Just do detection - no YOLO tracking
+        return self.infer(image, confidence_threshold, trigger_classes)
 
     def predict_classification(
         self,
@@ -294,11 +269,11 @@ class YOLOWrapper:
             raise RuntimeError(f"Model {self.model_id} not loaded")
 
         try:
-            # Run inference using predict method for classification (like ML engineer's approach)
-            results = self.model.predict(source=image, verbose=False)
+            # Run inference
+            results = self.model(image, verbose=False)
 
             # For classification models, extract probabilities
-            if results and len(results) > 0 and hasattr(results[0], 'probs') and results[0].probs is not None:
+            if hasattr(results[0], 'probs'):
                 probs = results[0].probs
                 top_indices = probs.top5[:top_k]
                 top_conf = probs.top5conf[:top_k].cpu().numpy()
@@ -310,7 +285,7 @@ class YOLOWrapper:
 
                 return predictions
             else:
-                logger.warning(f"Model {self.model_id} does not support classification or no probs found")
+                logger.warning(f"Model {self.model_id} does not support classification")
                 return {}
 
         except Exception as e:
@@ -353,20 +328,21 @@ class YOLOWrapper:
         """Get the number of classes the model can detect"""
         return len(self._class_names)
 
-    def is_classification_model(self) -> bool:
-        """Check if this is a classification model"""
-        return 'cls' in str(self.model_path).lower() or 'classify' in str(self.model_path).lower()
 
     def clear_cache(self) -> None:
-        """Clear model resources (no cache in isolated mode)"""
-        if self.model:
-            # Clear any model resources if needed
-            logger.info(f"Cleared resources for model {self.model_id} (no shared cache)")
+        """Clear the model cache"""
+        with self._cache_lock:
+            cache_key = str(self.model_path)
+            if cache_key in self._model_cache:
+                del self._model_cache[cache_key]
+                logger.info(f"Cleared cache for model {self.model_id}")
 
     @classmethod
     def clear_all_cache(cls) -> None:
-        """No-op in isolated mode (no shared cache to clear)"""
-        logger.info("No shared cache to clear in isolated mode")
+        """Clear all cached models"""
+        with cls._cache_lock:
+            cls._model_cache.clear()
+            logger.info("Cleared all model cache")
 
     def warmup(self, image_size: Tuple[int, int] = (640, 640)) -> None:
         """
@@ -417,17 +393,16 @@ class ModelInferenceManager:
             YOLOWrapper instance
         """
         with self._lock:
-            # Check if already loaded for this specific manager instance
+            # Check if already loaded
             if model_id in self.models:
-                logger.debug(f"Model {model_id} already loaded in this manager instance")
+                logger.debug(f"Model {model_id} already loaded")
                 return self.models[model_id]
 
-            # Load the model (each instance loads independently)
+            # Load the model
             model_path = self.model_dir / model_file
             if not model_path.exists():
                 raise FileNotFoundError(f"Model file not found: {model_path}")
 
-            logger.info(f"Loading model {model_id} in isolation for this manager instance")
             wrapper = YOLOWrapper(model_path, model_id, device)
             self.models[model_id] = wrapper
 
diff --git a/core/monitoring/__init__.py b/core/monitoring/__init__.py
new file mode 100644
index 0000000..2ad32ed
--- /dev/null
+++ b/core/monitoring/__init__.py
@@ -0,0 +1,18 @@
+"""
+Comprehensive health monitoring system for detector worker.
+Tracks stream health, thread responsiveness, and system performance.
+"""
+
+from .health import HealthMonitor, HealthStatus, HealthCheck
+from .stream_health import StreamHealthTracker
+from .thread_health import ThreadHealthMonitor
+from .recovery import RecoveryManager
+
+__all__ = [
+    'HealthMonitor',
+    'HealthStatus',
+    'HealthCheck',
+    'StreamHealthTracker',
+    'ThreadHealthMonitor',
+    'RecoveryManager'
+]
\ No newline at end of file
diff --git a/core/monitoring/health.py b/core/monitoring/health.py
new file mode 100644
index 0000000..be094f3
--- /dev/null
+++ b/core/monitoring/health.py
@@ -0,0 +1,456 @@
+"""
+Core health monitoring system for comprehensive stream and system health tracking.
+Provides centralized health status, alerting, and recovery coordination.
+"""
+import time
+import threading
+import logging
+import psutil
+from typing import Dict, List, Optional, Any, Callable
+from dataclasses import dataclass, field
+from enum import Enum
+from collections import defaultdict, deque
+
+
+logger = logging.getLogger(__name__)
+
+
+class HealthStatus(Enum):
+    """Health status levels."""
+    HEALTHY = "healthy"
+    WARNING = "warning"
+    CRITICAL = "critical"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class HealthCheck:
+    """Individual health check result."""
+    name: str
+    status: HealthStatus
+    message: str
+    timestamp: float = field(default_factory=time.time)
+    details: Dict[str, Any] = field(default_factory=dict)
+    recovery_action: Optional[str] = None
+
+
+@dataclass
+class HealthMetrics:
+    """Health metrics for a component."""
+    component_id: str
+    last_update: float
+    frame_count: int = 0
+    error_count: int = 0
+    warning_count: int = 0
+    restart_count: int = 0
+    avg_frame_interval: float = 0.0
+    last_frame_time: Optional[float] = None
+    thread_alive: bool = True
+    connection_healthy: bool = True
+    memory_usage_mb: float = 0.0
+    cpu_usage_percent: float = 0.0
+
+
+class HealthMonitor:
+    """Comprehensive health monitoring system."""
+
+    def __init__(self, check_interval: float = 30.0):
+        """
+        Initialize health monitor.
+
+        Args:
+            check_interval: Interval between health checks in seconds
+        """
+        self.check_interval = check_interval
+        self.running = False
+        self.monitor_thread = None
+        self._lock = threading.RLock()
+
+        # Health data storage
+        self.health_checks: Dict[str, HealthCheck] = {}
+        self.metrics: Dict[str, HealthMetrics] = {}
+        self.alert_history: deque = deque(maxlen=1000)
+        self.recovery_actions: deque = deque(maxlen=500)
+
+        # Thresholds (configurable)
+        self.thresholds = {
+            'frame_stale_warning_seconds': 120,    # 2 minutes
+            'frame_stale_critical_seconds': 300,   # 5 minutes
+            'thread_unresponsive_seconds': 60,     # 1 minute
+            'memory_warning_mb': 500,              # 500MB per stream
+            'memory_critical_mb': 1000,            # 1GB per stream
+            'cpu_warning_percent': 80,             # 80% CPU
+            'cpu_critical_percent': 95,            # 95% CPU
+            'error_rate_warning': 0.1,             # 10% error rate
+            'error_rate_critical': 0.3,            # 30% error rate
+            'restart_threshold': 3                 # Max restarts per hour
+        }
+
+        # Health check functions
+        self.health_checkers: List[Callable[[], List[HealthCheck]]] = []
+        self.recovery_callbacks: Dict[str, Callable[[str, HealthCheck], bool]] = {}
+
+        # System monitoring
+        self.process = psutil.Process()
+        self.system_start_time = time.time()
+
+    def start(self):
+        """Start health monitoring."""
+        if self.running:
+            logger.warning("Health monitor already running")
+            return
+
+        self.running = True
+        self.monitor_thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self.monitor_thread.start()
+        logger.info(f"Health monitor started (check interval: {self.check_interval}s)")
+
+    def stop(self):
+        """Stop health monitoring."""
+        self.running = False
+        if self.monitor_thread:
+            self.monitor_thread.join(timeout=5.0)
+        logger.info("Health monitor stopped")
+
+    def register_health_checker(self, checker: Callable[[], List[HealthCheck]]):
+        """Register a health check function."""
+        self.health_checkers.append(checker)
+        logger.debug(f"Registered health checker: {checker.__name__}")
+
+    def register_recovery_callback(self, component: str, callback: Callable[[str, HealthCheck], bool]):
+        """Register a recovery callback for a component."""
+        self.recovery_callbacks[component] = callback
+        logger.debug(f"Registered recovery callback for {component}")
+
+    def update_metrics(self, component_id: str, **kwargs):
+        """Update metrics for a component."""
+        with self._lock:
+            if component_id not in self.metrics:
+                self.metrics[component_id] = HealthMetrics(
+                    component_id=component_id,
+                    last_update=time.time()
+                )
+
+            metrics = self.metrics[component_id]
+            metrics.last_update = time.time()
+
+            # Update provided metrics
+            for key, value in kwargs.items():
+                if hasattr(metrics, key):
+                    setattr(metrics, key, value)
+
+    def report_frame_received(self, component_id: str):
+        """Report that a frame was received for a component."""
+        current_time = time.time()
+        with self._lock:
+            if component_id not in self.metrics:
+                self.metrics[component_id] = HealthMetrics(
+                    component_id=component_id,
+                    last_update=current_time
+                )
+
+            metrics = self.metrics[component_id]
+
+            # Update frame metrics
+            if metrics.last_frame_time:
+                interval = current_time - metrics.last_frame_time
+                # Moving average of frame intervals
+                if metrics.avg_frame_interval == 0:
+                    metrics.avg_frame_interval = interval
+                else:
+                    metrics.avg_frame_interval = (metrics.avg_frame_interval * 0.9) + (interval * 0.1)
+
+            metrics.last_frame_time = current_time
+            metrics.frame_count += 1
+            metrics.last_update = current_time
+
+    def report_error(self, component_id: str, error_type: str = "general"):
+        """Report an error for a component."""
+        with self._lock:
+            if component_id not in self.metrics:
+                self.metrics[component_id] = HealthMetrics(
+                    component_id=component_id,
+                    last_update=time.time()
+                )
+
+            self.metrics[component_id].error_count += 1
+            self.metrics[component_id].last_update = time.time()
+
+        logger.debug(f"Error reported for {component_id}: {error_type}")
+
+    def report_warning(self, component_id: str, warning_type: str = "general"):
+        """Report a warning for a component."""
+        with self._lock:
+            if component_id not in self.metrics:
+                self.metrics[component_id] = HealthMetrics(
+                    component_id=component_id,
+                    last_update=time.time()
+                )
+
+            self.metrics[component_id].warning_count += 1
+            self.metrics[component_id].last_update = time.time()
+
+        logger.debug(f"Warning reported for {component_id}: {warning_type}")
+
+    def report_restart(self, component_id: str):
+        """Report that a component was restarted."""
+        with self._lock:
+            if component_id not in self.metrics:
+                self.metrics[component_id] = HealthMetrics(
+                    component_id=component_id,
+                    last_update=time.time()
+                )
+
+            self.metrics[component_id].restart_count += 1
+            self.metrics[component_id].last_update = time.time()
+
+        # Log recovery action
+        recovery_action = {
+            'timestamp': time.time(),
+            'component': component_id,
+            'action': 'restart',
+            'reason': 'manual_restart'
+        }
+
+        with self._lock:
+            self.recovery_actions.append(recovery_action)
+
+        logger.info(f"Restart reported for {component_id}")
+
+    def get_health_status(self, component_id: Optional[str] = None) -> Dict[str, Any]:
+        """Get comprehensive health status."""
+        with self._lock:
+            if component_id:
+                # Get health for specific component
+                return self._get_component_health(component_id)
+            else:
+                # Get overall health status
+                return self._get_overall_health()
+
+    def _get_component_health(self, component_id: str) -> Dict[str, Any]:
+        """Get health status for a specific component."""
+        if component_id not in self.metrics:
+            return {
+                'component_id': component_id,
+                'status': HealthStatus.UNKNOWN.value,
+                'message': 'No metrics available',
+                'metrics': {}
+            }
+
+        metrics = self.metrics[component_id]
+        current_time = time.time()
+
+        # Determine health status
+        status = HealthStatus.HEALTHY
+        issues = []
+
+        # Check frame freshness
+        if metrics.last_frame_time:
+            frame_age = current_time - metrics.last_frame_time
+            if frame_age > self.thresholds['frame_stale_critical_seconds']:
+                status = HealthStatus.CRITICAL
+                issues.append(f"Frames stale for {frame_age:.1f}s")
+            elif frame_age > self.thresholds['frame_stale_warning_seconds']:
+                if status == HealthStatus.HEALTHY:
+                    status = HealthStatus.WARNING
+                issues.append(f"Frames aging ({frame_age:.1f}s)")
+
+        # Check error rates
+        if metrics.frame_count > 0:
+            error_rate = metrics.error_count / metrics.frame_count
+            if error_rate > self.thresholds['error_rate_critical']:
+                status = HealthStatus.CRITICAL
+                issues.append(f"High error rate ({error_rate:.1%})")
+            elif error_rate > self.thresholds['error_rate_warning']:
+                if status == HealthStatus.HEALTHY:
+                    status = HealthStatus.WARNING
+                issues.append(f"Elevated error rate ({error_rate:.1%})")
+
+        # Check restart frequency
+        restart_rate = metrics.restart_count / max(1, (current_time - self.system_start_time) / 3600)
+        if restart_rate > self.thresholds['restart_threshold']:
+            status = HealthStatus.CRITICAL
+            issues.append(f"Frequent restarts ({restart_rate:.1f}/hour)")
+
+        # Check thread health
+        if not metrics.thread_alive:
+            status = HealthStatus.CRITICAL
+            issues.append("Thread not alive")
+
+        # Check connection health
+        if not metrics.connection_healthy:
+            if status == HealthStatus.HEALTHY:
+                status = HealthStatus.WARNING
+            issues.append("Connection unhealthy")
+
+        return {
+            'component_id': component_id,
+            'status': status.value,
+            'message': '; '.join(issues) if issues else 'All checks passing',
+            'metrics': {
+                'frame_count': metrics.frame_count,
+                'error_count': metrics.error_count,
+                'warning_count': metrics.warning_count,
+                'restart_count': metrics.restart_count,
+                'avg_frame_interval': metrics.avg_frame_interval,
+                'last_frame_age': current_time - metrics.last_frame_time if metrics.last_frame_time else None,
+                'thread_alive': metrics.thread_alive,
+                'connection_healthy': metrics.connection_healthy,
+                'memory_usage_mb': metrics.memory_usage_mb,
+                'cpu_usage_percent': metrics.cpu_usage_percent,
+                'uptime_seconds': current_time - self.system_start_time
+            },
+            'last_update': metrics.last_update
+        }
+
+    def _get_overall_health(self) -> Dict[str, Any]:
+        """Get overall system health status."""
+        current_time = time.time()
+        components = {}
+        overall_status = HealthStatus.HEALTHY
+
+        # Get health for all components
+        for component_id in self.metrics.keys():
+            component_health = self._get_component_health(component_id)
+            components[component_id] = component_health
+
+            # Determine overall status
+            component_status = HealthStatus(component_health['status'])
+            if component_status == HealthStatus.CRITICAL:
+                overall_status = HealthStatus.CRITICAL
+            elif component_status == HealthStatus.WARNING and overall_status == HealthStatus.HEALTHY:
+                overall_status = HealthStatus.WARNING
+
+        # System metrics
+        try:
+            system_memory = self.process.memory_info()
+            system_cpu = self.process.cpu_percent()
+        except Exception:
+            system_memory = None
+            system_cpu = 0.0
+
+        return {
+            'overall_status': overall_status.value,
+            'timestamp': current_time,
+            'uptime_seconds': current_time - self.system_start_time,
+            'total_components': len(self.metrics),
+            'components': components,
+            'system_metrics': {
+                'memory_mb': system_memory.rss / (1024 * 1024) if system_memory else 0,
+                'cpu_percent': system_cpu,
+                'process_id': self.process.pid
+            },
+            'recent_alerts': list(self.alert_history)[-10:],  # Last 10 alerts
+            'recent_recoveries': list(self.recovery_actions)[-10:]  # Last 10 recovery actions
+        }
+
+    def _monitor_loop(self):
+        """Main health monitoring loop."""
+        logger.info("Health monitor loop started")
+
+        while self.running:
+            try:
+                start_time = time.time()
+
+                # Run all registered health checks
+                all_checks = []
+                for checker in self.health_checkers:
+                    try:
+                        checks = checker()
+                        all_checks.extend(checks)
+                    except Exception as e:
+                        logger.error(f"Error in health checker {checker.__name__}: {e}")
+
+                # Process health checks and trigger recovery if needed
+                for check in all_checks:
+                    self._process_health_check(check)
+
+                # Update system metrics
+                self._update_system_metrics()
+
+                # Sleep until next check
+                elapsed = time.time() - start_time
+                sleep_time = max(0, self.check_interval - elapsed)
+                if sleep_time > 0:
+                    time.sleep(sleep_time)
+
+            except Exception as e:
+                logger.error(f"Error in health monitor loop: {e}")
+                time.sleep(5.0)  # Fallback sleep
+
+        logger.info("Health monitor loop ended")
+
+    def _process_health_check(self, check: HealthCheck):
+        """Process a health check result and trigger recovery if needed."""
+        with self._lock:
+            # Store health check
+            self.health_checks[check.name] = check
+
+            # Log alerts for non-healthy status
+            if check.status != HealthStatus.HEALTHY:
+                alert = {
+                    'timestamp': check.timestamp,
+                    'component': check.name,
+                    'status': check.status.value,
+                    'message': check.message,
+                    'details': check.details
+                }
+                self.alert_history.append(alert)
+
+                logger.warning(f"Health alert [{check.status.value.upper()}] {check.name}: {check.message}")
+
+                # Trigger recovery if critical and recovery action available
+                if check.status == HealthStatus.CRITICAL and check.recovery_action:
+                    self._trigger_recovery(check.name, check)
+
+    def _trigger_recovery(self, component: str, check: HealthCheck):
+        """Trigger recovery action for a component."""
+        if component in self.recovery_callbacks:
+            try:
+                logger.info(f"Triggering recovery for {component}: {check.recovery_action}")
+
+                success = self.recovery_callbacks[component](component, check)
+
+                recovery_action = {
+                    'timestamp': time.time(),
+                    'component': component,
+                    'action': check.recovery_action,
+                    'reason': check.message,
+                    'success': success
+                }
+
+                with self._lock:
+                    self.recovery_actions.append(recovery_action)
+
+                if success:
+                    logger.info(f"Recovery successful for {component}")
+                else:
+                    logger.error(f"Recovery failed for {component}")
+
+            except Exception as e:
+                logger.error(f"Error in recovery callback for {component}: {e}")
+
+    def _update_system_metrics(self):
+        """Update system-level metrics."""
+        try:
+            # Update process metrics for all components
+            current_time = time.time()
+
+            with self._lock:
+                for component_id, metrics in self.metrics.items():
+                    # Update CPU and memory if available
+                    try:
+                        # This is a simplified approach - in practice you'd want
+                        # per-thread or per-component resource tracking
+                        metrics.cpu_usage_percent = self.process.cpu_percent() / len(self.metrics)
+                        memory_info = self.process.memory_info()
+                        metrics.memory_usage_mb = memory_info.rss / (1024 * 1024) / len(self.metrics)
+                    except Exception:
+                        pass
+
+        except Exception as e:
+            logger.error(f"Error updating system metrics: {e}")
+
+
+# Global health monitor instance
+health_monitor = HealthMonitor()
\ No newline at end of file
diff --git a/core/monitoring/recovery.py b/core/monitoring/recovery.py
new file mode 100644
index 0000000..4ea16dc
--- /dev/null
+++ b/core/monitoring/recovery.py
@@ -0,0 +1,385 @@
+"""
+Recovery manager for automatic handling of health issues.
+Provides circuit breaker patterns, automatic restarts, and graceful degradation.
+"""
+import time
+import logging
+import threading
+from typing import Dict, List, Optional, Any, Callable
+from dataclasses import dataclass
+from enum import Enum
+from collections import defaultdict, deque
+
+from .health import HealthCheck, HealthStatus, health_monitor
+
+
+logger = logging.getLogger(__name__)
+
+
+class RecoveryAction(Enum):
+    """Types of recovery actions."""
+    RESTART_STREAM = "restart_stream"
+    RESTART_THREAD = "restart_thread"
+    CLEAR_BUFFER = "clear_buffer"
+    RECONNECT = "reconnect"
+    THROTTLE = "throttle"
+    DISABLE = "disable"
+
+
+@dataclass
+class RecoveryAttempt:
+    """Record of a recovery attempt."""
+    timestamp: float
+    component: str
+    action: RecoveryAction
+    reason: str
+    success: bool
+    details: Dict[str, Any] = None
+
+
+@dataclass
+class RecoveryState:
+    """Recovery state for a component - simplified without circuit breaker."""
+    failure_count: int = 0
+    success_count: int = 0
+    last_failure_time: Optional[float] = None
+    last_success_time: Optional[float] = None
+
+
+class RecoveryManager:
+    """Manages automatic recovery actions for health issues."""
+
+    def __init__(self):
+        self.recovery_handlers: Dict[str, Callable[[str, HealthCheck], bool]] = {}
+        self.recovery_states: Dict[str, RecoveryState] = {}
+        self.recovery_history: deque = deque(maxlen=1000)
+        self._lock = threading.RLock()
+
+        # Configuration - simplified without circuit breaker
+        self.recovery_cooldown = 30          # 30 seconds between recovery attempts
+        self.max_attempts_per_hour = 20      # Still limit to prevent spam, but much higher
+
+        # Track recovery attempts per component
+        self.recovery_attempts: Dict[str, deque] = defaultdict(lambda: deque(maxlen=50))
+
+        # Register with health monitor
+        health_monitor.register_recovery_callback("stream", self._handle_stream_recovery)
+        health_monitor.register_recovery_callback("thread", self._handle_thread_recovery)
+        health_monitor.register_recovery_callback("buffer", self._handle_buffer_recovery)
+
+    def register_recovery_handler(self, action: RecoveryAction, handler: Callable[[str, Dict[str, Any]], bool]):
+        """
+        Register a recovery handler for a specific action.
+
+        Args:
+            action: Type of recovery action
+            handler: Function that performs the recovery
+        """
+        self.recovery_handlers[action.value] = handler
+        logger.info(f"Registered recovery handler for {action.value}")
+
+    def can_attempt_recovery(self, component: str) -> bool:
+        """
+        Check if recovery can be attempted for a component.
+
+        Args:
+            component: Component identifier
+
+        Returns:
+            True if recovery can be attempted (always allow with minimal throttling)
+        """
+        with self._lock:
+            current_time = time.time()
+
+            # Check recovery attempt rate limiting (much more permissive)
+            recent_attempts = [
+                attempt for attempt in self.recovery_attempts[component]
+                if current_time - attempt <= 3600  # Last hour
+            ]
+
+            # Only block if truly excessive attempts
+            if len(recent_attempts) >= self.max_attempts_per_hour:
+                logger.warning(f"Recovery rate limit exceeded for {component} "
+                             f"({len(recent_attempts)} attempts in last hour)")
+                return False
+
+            # Check cooldown period (shorter cooldown)
+            if recent_attempts:
+                last_attempt = max(recent_attempts)
+                if current_time - last_attempt < self.recovery_cooldown:
+                    logger.debug(f"Recovery cooldown active for {component} "
+                               f"(last attempt {current_time - last_attempt:.1f}s ago)")
+                    return False
+
+            return True
+
+    def attempt_recovery(self, component: str, action: RecoveryAction, reason: str,
+                        details: Optional[Dict[str, Any]] = None) -> bool:
+        """
+        Attempt recovery for a component.
+
+        Args:
+            component: Component identifier
+            action: Recovery action to perform
+            reason: Reason for recovery
+            details: Additional details
+
+        Returns:
+            True if recovery was successful
+        """
+        if not self.can_attempt_recovery(component):
+            return False
+
+        current_time = time.time()
+
+        logger.info(f"Attempting recovery for {component}: {action.value} ({reason})")
+
+        try:
+            # Record recovery attempt
+            with self._lock:
+                self.recovery_attempts[component].append(current_time)
+
+            # Perform recovery action
+            success = self._execute_recovery_action(component, action, details or {})
+
+            # Record recovery result
+            attempt = RecoveryAttempt(
+                timestamp=current_time,
+                component=component,
+                action=action,
+                reason=reason,
+                success=success,
+                details=details
+            )
+
+            with self._lock:
+                self.recovery_history.append(attempt)
+
+            # Update recovery state
+            self._update_recovery_state(component, success)
+
+            if success:
+                logger.info(f"Recovery successful for {component}: {action.value}")
+            else:
+                logger.error(f"Recovery failed for {component}: {action.value}")
+
+            return success
+
+        except Exception as e:
+            logger.error(f"Error during recovery for {component}: {e}")
+            self._update_recovery_state(component, False)
+            return False
+
+    def _execute_recovery_action(self, component: str, action: RecoveryAction,
+                               details: Dict[str, Any]) -> bool:
+        """Execute a specific recovery action."""
+        handler_key = action.value
+
+        if handler_key not in self.recovery_handlers:
+            logger.error(f"No recovery handler registered for action: {handler_key}")
+            return False
+
+        try:
+            handler = self.recovery_handlers[handler_key]
+            return handler(component, details)
+
+        except Exception as e:
+            logger.error(f"Error executing recovery action {handler_key} for {component}: {e}")
+            return False
+
+    def _update_recovery_state(self, component: str, success: bool):
+        """Update recovery state based on recovery result."""
+        current_time = time.time()
+
+        with self._lock:
+            if component not in self.recovery_states:
+                self.recovery_states[component] = RecoveryState()
+
+            state = self.recovery_states[component]
+
+            if success:
+                state.success_count += 1
+                state.last_success_time = current_time
+                # Reset failure count on success
+                state.failure_count = max(0, state.failure_count - 1)
+                logger.debug(f"Recovery success for {component} (total successes: {state.success_count})")
+            else:
+                state.failure_count += 1
+                state.last_failure_time = current_time
+                logger.debug(f"Recovery failure for {component} (total failures: {state.failure_count})")
+
+    def _handle_stream_recovery(self, component: str, health_check: HealthCheck) -> bool:
+        """Handle recovery for stream-related issues."""
+        if "frames" in health_check.name:
+            # Frame-related issue - restart stream
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RESTART_STREAM,
+                health_check.message,
+                health_check.details
+            )
+        elif "connection" in health_check.name:
+            # Connection issue - reconnect
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RECONNECT,
+                health_check.message,
+                health_check.details
+            )
+        elif "errors" in health_check.name:
+            # High error rate - throttle or restart
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.THROTTLE,
+                health_check.message,
+                health_check.details
+            )
+        else:
+            # Generic stream issue - restart
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RESTART_STREAM,
+                health_check.message,
+                health_check.details
+            )
+
+    def _handle_thread_recovery(self, component: str, health_check: HealthCheck) -> bool:
+        """Handle recovery for thread-related issues."""
+        if "deadlock" in health_check.name:
+            # Deadlock detected - restart thread
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RESTART_THREAD,
+                health_check.message,
+                health_check.details
+            )
+        elif "responsive" in health_check.name:
+            # Thread unresponsive - restart
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RESTART_THREAD,
+                health_check.message,
+                health_check.details
+            )
+        else:
+            # Generic thread issue - restart
+            return self.attempt_recovery(
+                component,
+                RecoveryAction.RESTART_THREAD,
+                health_check.message,
+                health_check.details
+            )
+
+    def _handle_buffer_recovery(self, component: str, health_check: HealthCheck) -> bool:
+        """Handle recovery for buffer-related issues."""
+        # Buffer issues - clear buffer
+        return self.attempt_recovery(
+            component,
+            RecoveryAction.CLEAR_BUFFER,
+            health_check.message,
+            health_check.details
+        )
+
+    def get_recovery_stats(self) -> Dict[str, Any]:
+        """Get recovery statistics."""
+        current_time = time.time()
+
+        with self._lock:
+            # Calculate stats from history
+            recent_recoveries = [
+                attempt for attempt in self.recovery_history
+                if current_time - attempt.timestamp <= 3600  # Last hour
+            ]
+
+            stats_by_component = defaultdict(lambda: {
+                'attempts': 0,
+                'successes': 0,
+                'failures': 0,
+                'last_attempt': None,
+                'last_success': None
+            })
+
+            for attempt in recent_recoveries:
+                stats = stats_by_component[attempt.component]
+                stats['attempts'] += 1
+
+                if attempt.success:
+                    stats['successes'] += 1
+                    if not stats['last_success'] or attempt.timestamp > stats['last_success']:
+                        stats['last_success'] = attempt.timestamp
+                else:
+                    stats['failures'] += 1
+
+                if not stats['last_attempt'] or attempt.timestamp > stats['last_attempt']:
+                    stats['last_attempt'] = attempt.timestamp
+
+            return {
+                'total_recoveries_last_hour': len(recent_recoveries),
+                'recovery_by_component': dict(stats_by_component),
+                'recovery_states': {
+                    component: {
+                        'failure_count': state.failure_count,
+                        'success_count': state.success_count,
+                        'last_failure_time': state.last_failure_time,
+                        'last_success_time': state.last_success_time
+                    }
+                    for component, state in self.recovery_states.items()
+                },
+                'recent_history': [
+                    {
+                        'timestamp': attempt.timestamp,
+                        'component': attempt.component,
+                        'action': attempt.action.value,
+                        'reason': attempt.reason,
+                        'success': attempt.success
+                    }
+                    for attempt in list(self.recovery_history)[-10:]  # Last 10 attempts
+                ]
+            }
+
+    def force_recovery(self, component: str, action: RecoveryAction, reason: str = "manual") -> bool:
+        """
+        Force recovery for a component, bypassing rate limiting.
+
+        Args:
+            component: Component identifier
+            action: Recovery action to perform
+            reason: Reason for forced recovery
+
+        Returns:
+            True if recovery was successful
+        """
+        logger.info(f"Forcing recovery for {component}: {action.value} ({reason})")
+
+        current_time = time.time()
+
+        try:
+            # Execute recovery action directly
+            success = self._execute_recovery_action(component, action, {})
+
+            # Record forced recovery
+            attempt = RecoveryAttempt(
+                timestamp=current_time,
+                component=component,
+                action=action,
+                reason=f"forced: {reason}",
+                success=success,
+                details={'forced': True}
+            )
+
+            with self._lock:
+                self.recovery_history.append(attempt)
+                self.recovery_attempts[component].append(current_time)
+
+            # Update recovery state
+            self._update_recovery_state(component, success)
+
+            return success
+
+        except Exception as e:
+            logger.error(f"Error during forced recovery for {component}: {e}")
+            return False
+
+
+# Global recovery manager instance
+recovery_manager = RecoveryManager()
\ No newline at end of file
diff --git a/core/monitoring/stream_health.py b/core/monitoring/stream_health.py
new file mode 100644
index 0000000..770dfe4
--- /dev/null
+++ b/core/monitoring/stream_health.py
@@ -0,0 +1,351 @@
+"""
+Stream-specific health monitoring for video streams.
+Tracks frame production, connection health, and stream-specific metrics.
+"""
+import time
+import logging
+import threading
+import requests
+from typing import Dict, Optional, List, Any
+from collections import deque
+from dataclasses import dataclass
+
+from .health import HealthCheck, HealthStatus, health_monitor
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class StreamMetrics:
+    """Metrics for an individual stream."""
+    camera_id: str
+    stream_type: str  # 'rtsp', 'http_snapshot'
+    start_time: float
+    last_frame_time: Optional[float] = None
+    frame_count: int = 0
+    error_count: int = 0
+    reconnect_count: int = 0
+    bytes_received: int = 0
+    frames_per_second: float = 0.0
+    connection_attempts: int = 0
+    last_connection_test: Optional[float] = None
+    connection_healthy: bool = True
+    last_error: Optional[str] = None
+    last_error_time: Optional[float] = None
+
+
+class StreamHealthTracker:
+    """Tracks health for individual video streams."""
+
+    def __init__(self):
+        self.streams: Dict[str, StreamMetrics] = {}
+        self._lock = threading.RLock()
+
+        # Configuration
+        self.connection_test_interval = 300  # Test connection every 5 minutes
+        self.frame_timeout_warning = 120    # Warn if no frames for 2 minutes
+        self.frame_timeout_critical = 300   # Critical if no frames for 5 minutes
+        self.error_rate_threshold = 0.1     # 10% error rate threshold
+
+        # Register with health monitor
+        health_monitor.register_health_checker(self._perform_health_checks)
+
+    def register_stream(self, camera_id: str, stream_type: str, source_url: Optional[str] = None):
+        """Register a new stream for monitoring."""
+        with self._lock:
+            if camera_id not in self.streams:
+                self.streams[camera_id] = StreamMetrics(
+                    camera_id=camera_id,
+                    stream_type=stream_type,
+                    start_time=time.time()
+                )
+                logger.info(f"Registered stream for monitoring: {camera_id} ({stream_type})")
+
+            # Update health monitor metrics
+            health_monitor.update_metrics(
+                camera_id,
+                thread_alive=True,
+                connection_healthy=True
+            )
+
+    def unregister_stream(self, camera_id: str):
+        """Unregister a stream from monitoring."""
+        with self._lock:
+            if camera_id in self.streams:
+                del self.streams[camera_id]
+                logger.info(f"Unregistered stream from monitoring: {camera_id}")
+
+    def report_frame_received(self, camera_id: str, frame_size_bytes: int = 0):
+        """Report that a frame was received."""
+        current_time = time.time()
+
+        with self._lock:
+            if camera_id not in self.streams:
+                logger.warning(f"Frame received for unregistered stream: {camera_id}")
+                return
+
+            stream = self.streams[camera_id]
+
+            # Update frame metrics
+            if stream.last_frame_time:
+                interval = current_time - stream.last_frame_time
+                # Calculate FPS as moving average
+                if stream.frames_per_second == 0:
+                    stream.frames_per_second = 1.0 / interval if interval > 0 else 0
+                else:
+                    new_fps = 1.0 / interval if interval > 0 else 0
+                    stream.frames_per_second = (stream.frames_per_second * 0.9) + (new_fps * 0.1)
+
+            stream.last_frame_time = current_time
+            stream.frame_count += 1
+            stream.bytes_received += frame_size_bytes
+
+            # Report to health monitor
+            health_monitor.report_frame_received(camera_id)
+            health_monitor.update_metrics(
+                camera_id,
+                frame_count=stream.frame_count,
+                avg_frame_interval=1.0 / stream.frames_per_second if stream.frames_per_second > 0 else 0,
+                last_frame_time=current_time
+            )
+
+    def report_error(self, camera_id: str, error_message: str):
+        """Report an error for a stream."""
+        current_time = time.time()
+
+        with self._lock:
+            if camera_id not in self.streams:
+                logger.warning(f"Error reported for unregistered stream: {camera_id}")
+                return
+
+            stream = self.streams[camera_id]
+            stream.error_count += 1
+            stream.last_error = error_message
+            stream.last_error_time = current_time
+
+            # Report to health monitor
+            health_monitor.report_error(camera_id, "stream_error")
+            health_monitor.update_metrics(
+                camera_id,
+                error_count=stream.error_count
+            )
+
+            logger.debug(f"Error reported for stream {camera_id}: {error_message}")
+
+    def report_reconnect(self, camera_id: str, reason: str = "unknown"):
+        """Report that a stream reconnected."""
+        current_time = time.time()
+
+        with self._lock:
+            if camera_id not in self.streams:
+                logger.warning(f"Reconnect reported for unregistered stream: {camera_id}")
+                return
+
+            stream = self.streams[camera_id]
+            stream.reconnect_count += 1
+
+            # Report to health monitor
+            health_monitor.report_restart(camera_id)
+            health_monitor.update_metrics(
+                camera_id,
+                restart_count=stream.reconnect_count
+            )
+
+            logger.info(f"Reconnect reported for stream {camera_id}: {reason}")
+
+    def report_connection_attempt(self, camera_id: str, success: bool):
+        """Report a connection attempt."""
+        with self._lock:
+            if camera_id not in self.streams:
+                return
+
+            stream = self.streams[camera_id]
+            stream.connection_attempts += 1
+            stream.connection_healthy = success
+
+            # Report to health monitor
+            health_monitor.update_metrics(
+                camera_id,
+                connection_healthy=success
+            )
+
+    def test_http_connection(self, camera_id: str, url: str) -> bool:
+        """Test HTTP connection health for snapshot streams."""
+        try:
+            # Quick HEAD request to test connectivity
+            response = requests.head(url, timeout=5, verify=False)
+            success = response.status_code in [200, 404]  # 404 might be normal for some cameras
+
+            self.report_connection_attempt(camera_id, success)
+
+            if success:
+                logger.debug(f"Connection test passed for {camera_id}")
+            else:
+                logger.warning(f"Connection test failed for {camera_id}: HTTP {response.status_code}")
+
+            return success
+
+        except Exception as e:
+            logger.warning(f"Connection test failed for {camera_id}: {e}")
+            self.report_connection_attempt(camera_id, False)
+            return False
+
+    def get_stream_metrics(self, camera_id: str) -> Optional[Dict[str, Any]]:
+        """Get metrics for a specific stream."""
+        with self._lock:
+            if camera_id not in self.streams:
+                return None
+
+            stream = self.streams[camera_id]
+            current_time = time.time()
+
+            # Calculate derived metrics
+            uptime = current_time - stream.start_time
+            frame_age = current_time - stream.last_frame_time if stream.last_frame_time else None
+            error_rate = stream.error_count / max(1, stream.frame_count)
+
+            return {
+                'camera_id': camera_id,
+                'stream_type': stream.stream_type,
+                'uptime_seconds': uptime,
+                'frame_count': stream.frame_count,
+                'frames_per_second': stream.frames_per_second,
+                'bytes_received': stream.bytes_received,
+                'error_count': stream.error_count,
+                'error_rate': error_rate,
+                'reconnect_count': stream.reconnect_count,
+                'connection_attempts': stream.connection_attempts,
+                'connection_healthy': stream.connection_healthy,
+                'last_frame_age_seconds': frame_age,
+                'last_error': stream.last_error,
+                'last_error_time': stream.last_error_time
+            }
+
+    def get_all_metrics(self) -> Dict[str, Dict[str, Any]]:
+        """Get metrics for all streams."""
+        with self._lock:
+            return {
+                camera_id: self.get_stream_metrics(camera_id)
+                for camera_id in self.streams.keys()
+            }
+
+    def _perform_health_checks(self) -> List[HealthCheck]:
+        """Perform health checks for all streams."""
+        checks = []
+        current_time = time.time()
+
+        with self._lock:
+            for camera_id, stream in self.streams.items():
+                checks.extend(self._check_stream_health(camera_id, stream, current_time))
+
+        return checks
+
+    def _check_stream_health(self, camera_id: str, stream: StreamMetrics, current_time: float) -> List[HealthCheck]:
+        """Perform health checks for a single stream."""
+        checks = []
+
+        # Check frame freshness
+        if stream.last_frame_time:
+            frame_age = current_time - stream.last_frame_time
+
+            if frame_age > self.frame_timeout_critical:
+                checks.append(HealthCheck(
+                    name=f"stream_{camera_id}_frames",
+                    status=HealthStatus.CRITICAL,
+                    message=f"No frames for {frame_age:.1f}s (critical threshold: {self.frame_timeout_critical}s)",
+                    details={
+                        'frame_age': frame_age,
+                        'threshold': self.frame_timeout_critical,
+                        'last_frame_time': stream.last_frame_time
+                    },
+                    recovery_action="restart_stream"
+                ))
+            elif frame_age > self.frame_timeout_warning:
+                checks.append(HealthCheck(
+                    name=f"stream_{camera_id}_frames",
+                    status=HealthStatus.WARNING,
+                    message=f"Frames aging: {frame_age:.1f}s (warning threshold: {self.frame_timeout_warning}s)",
+                    details={
+                        'frame_age': frame_age,
+                        'threshold': self.frame_timeout_warning,
+                        'last_frame_time': stream.last_frame_time
+                    }
+                ))
+        else:
+            # No frames received yet
+            startup_time = current_time - stream.start_time
+            if startup_time > 60:  # Allow 1 minute for initial connection
+                checks.append(HealthCheck(
+                    name=f"stream_{camera_id}_startup",
+                    status=HealthStatus.CRITICAL,
+                    message=f"No frames received since startup {startup_time:.1f}s ago",
+                    details={
+                        'startup_time': startup_time,
+                        'start_time': stream.start_time
+                    },
+                    recovery_action="restart_stream"
+                ))
+
+        # Check error rate
+        if stream.frame_count > 10:  # Need sufficient samples
+            error_rate = stream.error_count / stream.frame_count
+            if error_rate > self.error_rate_threshold:
+                checks.append(HealthCheck(
+                    name=f"stream_{camera_id}_errors",
+                    status=HealthStatus.WARNING,
+                    message=f"High error rate: {error_rate:.1%} ({stream.error_count}/{stream.frame_count})",
+                    details={
+                        'error_rate': error_rate,
+                        'error_count': stream.error_count,
+                        'frame_count': stream.frame_count,
+                        'last_error': stream.last_error
+                    }
+                ))
+
+        # Check connection health
+        if not stream.connection_healthy:
+            checks.append(HealthCheck(
+                name=f"stream_{camera_id}_connection",
+                status=HealthStatus.WARNING,
+                message="Connection unhealthy (last test failed)",
+                details={
+                    'connection_attempts': stream.connection_attempts,
+                    'last_connection_test': stream.last_connection_test
+                }
+            ))
+
+        # Check excessive reconnects
+        uptime_hours = (current_time - stream.start_time) / 3600
+        if uptime_hours > 1 and stream.reconnect_count > 5:  # More than 5 reconnects per hour
+            reconnect_rate = stream.reconnect_count / uptime_hours
+            checks.append(HealthCheck(
+                name=f"stream_{camera_id}_stability",
+                status=HealthStatus.WARNING,
+                message=f"Frequent reconnects: {reconnect_rate:.1f}/hour ({stream.reconnect_count} total)",
+                details={
+                    'reconnect_rate': reconnect_rate,
+                    'reconnect_count': stream.reconnect_count,
+                    'uptime_hours': uptime_hours
+                }
+            ))
+
+        # Check frame rate health
+        if stream.last_frame_time and stream.frames_per_second > 0:
+            expected_fps = 6.0  # Expected FPS for streams
+            if stream.frames_per_second < expected_fps * 0.5:  # Less than 50% of expected
+                checks.append(HealthCheck(
+                    name=f"stream_{camera_id}_framerate",
+                    status=HealthStatus.WARNING,
+                    message=f"Low frame rate: {stream.frames_per_second:.1f} fps (expected: ~{expected_fps} fps)",
+                    details={
+                        'current_fps': stream.frames_per_second,
+                        'expected_fps': expected_fps
+                    }
+                ))
+
+        return checks
+
+
+# Global stream health tracker instance
+stream_health_tracker = StreamHealthTracker()
\ No newline at end of file
diff --git a/core/monitoring/thread_health.py b/core/monitoring/thread_health.py
new file mode 100644
index 0000000..a29625b
--- /dev/null
+++ b/core/monitoring/thread_health.py
@@ -0,0 +1,381 @@
+"""
+Thread health monitoring for detecting unresponsive and deadlocked threads.
+Provides thread liveness detection and responsiveness testing.
+"""
+import time
+import threading
+import logging
+import signal
+import traceback
+from typing import Dict, List, Optional, Any, Callable
+from dataclasses import dataclass
+from collections import defaultdict
+
+from .health import HealthCheck, HealthStatus, health_monitor
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ThreadInfo:
+    """Information about a monitored thread."""
+    thread_id: int
+    thread_name: str
+    start_time: float
+    last_heartbeat: float
+    heartbeat_count: int = 0
+    is_responsive: bool = True
+    last_activity: Optional[str] = None
+    stack_traces: List[str] = None
+
+
+class ThreadHealthMonitor:
+    """Monitors thread health and responsiveness."""
+
+    def __init__(self):
+        self.monitored_threads: Dict[int, ThreadInfo] = {}
+        self.heartbeat_callbacks: Dict[int, Callable[[], bool]] = {}
+        self._lock = threading.RLock()
+
+        # Configuration
+        self.heartbeat_timeout = 60.0      # 1 minute without heartbeat = unresponsive
+        self.responsiveness_test_interval = 30.0  # Test responsiveness every 30 seconds
+        self.stack_trace_count = 5         # Keep last 5 stack traces for analysis
+
+        # Register with health monitor
+        health_monitor.register_health_checker(self._perform_health_checks)
+
+        # Enable periodic responsiveness testing
+        self.test_thread = threading.Thread(target=self._responsiveness_test_loop, daemon=True)
+        self.test_thread.start()
+
+    def register_thread(self, thread: threading.Thread, heartbeat_callback: Optional[Callable[[], bool]] = None):
+        """
+        Register a thread for monitoring.
+
+        Args:
+            thread: Thread to monitor
+            heartbeat_callback: Optional callback to test thread responsiveness
+        """
+        with self._lock:
+            thread_info = ThreadInfo(
+                thread_id=thread.ident,
+                thread_name=thread.name,
+                start_time=time.time(),
+                last_heartbeat=time.time()
+            )
+
+            self.monitored_threads[thread.ident] = thread_info
+
+            if heartbeat_callback:
+                self.heartbeat_callbacks[thread.ident] = heartbeat_callback
+
+            logger.info(f"Registered thread for monitoring: {thread.name} (ID: {thread.ident})")
+
+    def unregister_thread(self, thread_id: int):
+        """Unregister a thread from monitoring."""
+        with self._lock:
+            if thread_id in self.monitored_threads:
+                thread_name = self.monitored_threads[thread_id].thread_name
+                del self.monitored_threads[thread_id]
+
+                if thread_id in self.heartbeat_callbacks:
+                    del self.heartbeat_callbacks[thread_id]
+
+                logger.info(f"Unregistered thread from monitoring: {thread_name} (ID: {thread_id})")
+
+    def heartbeat(self, thread_id: Optional[int] = None, activity: Optional[str] = None):
+        """
+        Report thread heartbeat.
+
+        Args:
+            thread_id: Thread ID (uses current thread if None)
+            activity: Description of current activity
+        """
+        if thread_id is None:
+            thread_id = threading.current_thread().ident
+
+        current_time = time.time()
+
+        with self._lock:
+            if thread_id in self.monitored_threads:
+                thread_info = self.monitored_threads[thread_id]
+                thread_info.last_heartbeat = current_time
+                thread_info.heartbeat_count += 1
+                thread_info.is_responsive = True
+
+                if activity:
+                    thread_info.last_activity = activity
+
+                # Report to health monitor
+                health_monitor.update_metrics(
+                    f"thread_{thread_info.thread_name}",
+                    thread_alive=True,
+                    last_frame_time=current_time
+                )
+
+    def get_thread_info(self, thread_id: int) -> Optional[Dict[str, Any]]:
+        """Get information about a monitored thread."""
+        with self._lock:
+            if thread_id not in self.monitored_threads:
+                return None
+
+            thread_info = self.monitored_threads[thread_id]
+            current_time = time.time()
+
+            return {
+                'thread_id': thread_id,
+                'thread_name': thread_info.thread_name,
+                'uptime_seconds': current_time - thread_info.start_time,
+                'last_heartbeat_age': current_time - thread_info.last_heartbeat,
+                'heartbeat_count': thread_info.heartbeat_count,
+                'is_responsive': thread_info.is_responsive,
+                'last_activity': thread_info.last_activity,
+                'stack_traces': thread_info.stack_traces or []
+            }
+
+    def get_all_thread_info(self) -> Dict[int, Dict[str, Any]]:
+        """Get information about all monitored threads."""
+        with self._lock:
+            return {
+                thread_id: self.get_thread_info(thread_id)
+                for thread_id in self.monitored_threads.keys()
+            }
+
+    def test_thread_responsiveness(self, thread_id: int) -> bool:
+        """
+        Test if a thread is responsive by calling its heartbeat callback.
+
+        Args:
+            thread_id: ID of thread to test
+
+        Returns:
+            True if thread responds within timeout
+        """
+        if thread_id not in self.heartbeat_callbacks:
+            return True  # Can't test if no callback provided
+
+        try:
+            # Call the heartbeat callback with a timeout
+            callback = self.heartbeat_callbacks[thread_id]
+
+            # This is a simple approach - in practice you might want to use
+            # threading.Timer or asyncio for more sophisticated timeout handling
+            start_time = time.time()
+            result = callback()
+            response_time = time.time() - start_time
+
+            with self._lock:
+                if thread_id in self.monitored_threads:
+                    self.monitored_threads[thread_id].is_responsive = result
+
+            if response_time > 5.0:  # Slow response
+                logger.warning(f"Thread {thread_id} slow response: {response_time:.1f}s")
+
+            return result
+
+        except Exception as e:
+            logger.error(f"Error testing thread {thread_id} responsiveness: {e}")
+            with self._lock:
+                if thread_id in self.monitored_threads:
+                    self.monitored_threads[thread_id].is_responsive = False
+            return False
+
+    def capture_stack_trace(self, thread_id: int) -> Optional[str]:
+        """
+        Capture stack trace for a thread.
+
+        Args:
+            thread_id: ID of thread to capture
+
+        Returns:
+            Stack trace string or None if not available
+        """
+        try:
+            # Get all frames for all threads
+            frames = dict(threading._current_frames())
+
+            if thread_id not in frames:
+                return None
+
+            # Format stack trace
+            frame = frames[thread_id]
+            stack_trace = ''.join(traceback.format_stack(frame))
+
+            # Store in thread info
+            with self._lock:
+                if thread_id in self.monitored_threads:
+                    thread_info = self.monitored_threads[thread_id]
+                    if thread_info.stack_traces is None:
+                        thread_info.stack_traces = []
+
+                    thread_info.stack_traces.append(f"{time.time()}: {stack_trace}")
+
+                    # Keep only last N stack traces
+                    if len(thread_info.stack_traces) > self.stack_trace_count:
+                        thread_info.stack_traces = thread_info.stack_traces[-self.stack_trace_count:]
+
+            return stack_trace
+
+        except Exception as e:
+            logger.error(f"Error capturing stack trace for thread {thread_id}: {e}")
+            return None
+
+    def detect_deadlocks(self) -> List[Dict[str, Any]]:
+        """
+        Attempt to detect potential deadlocks by analyzing thread states.
+
+        Returns:
+            List of potential deadlock scenarios
+        """
+        deadlocks = []
+        current_time = time.time()
+
+        with self._lock:
+            # Look for threads that haven't had heartbeats for a long time
+            # and are supposedly alive
+            for thread_id, thread_info in self.monitored_threads.items():
+                heartbeat_age = current_time - thread_info.last_heartbeat
+
+                if heartbeat_age > self.heartbeat_timeout * 2:  # Double the timeout
+                    # Check if thread still exists
+                    thread_exists = any(
+                        t.ident == thread_id and t.is_alive()
+                        for t in threading.enumerate()
+                    )
+
+                    if thread_exists:
+                        # Thread exists but not responding - potential deadlock
+                        stack_trace = self.capture_stack_trace(thread_id)
+
+                        deadlock_info = {
+                            'thread_id': thread_id,
+                            'thread_name': thread_info.thread_name,
+                            'heartbeat_age': heartbeat_age,
+                            'last_activity': thread_info.last_activity,
+                            'stack_trace': stack_trace,
+                            'detection_time': current_time
+                        }
+
+                        deadlocks.append(deadlock_info)
+                        logger.warning(f"Potential deadlock detected in thread {thread_info.thread_name}")
+
+        return deadlocks
+
+    def _responsiveness_test_loop(self):
+        """Background loop to test thread responsiveness."""
+        logger.info("Thread responsiveness testing started")
+
+        while True:
+            try:
+                time.sleep(self.responsiveness_test_interval)
+
+                with self._lock:
+                    thread_ids = list(self.monitored_threads.keys())
+
+                for thread_id in thread_ids:
+                    try:
+                        self.test_thread_responsiveness(thread_id)
+                    except Exception as e:
+                        logger.error(f"Error testing thread {thread_id}: {e}")
+
+            except Exception as e:
+                logger.error(f"Error in responsiveness test loop: {e}")
+                time.sleep(10.0)  # Fallback sleep
+
+    def _perform_health_checks(self) -> List[HealthCheck]:
+        """Perform health checks for all monitored threads."""
+        checks = []
+        current_time = time.time()
+
+        with self._lock:
+            for thread_id, thread_info in self.monitored_threads.items():
+                checks.extend(self._check_thread_health(thread_id, thread_info, current_time))
+
+        # Check for deadlocks
+        deadlocks = self.detect_deadlocks()
+        for deadlock in deadlocks:
+            checks.append(HealthCheck(
+                name=f"deadlock_detection_{deadlock['thread_id']}",
+                status=HealthStatus.CRITICAL,
+                message=f"Potential deadlock in thread {deadlock['thread_name']} "
+                       f"(unresponsive for {deadlock['heartbeat_age']:.1f}s)",
+                details=deadlock,
+                recovery_action="restart_thread"
+            ))
+
+        return checks
+
+    def _check_thread_health(self, thread_id: int, thread_info: ThreadInfo, current_time: float) -> List[HealthCheck]:
+        """Perform health checks for a single thread."""
+        checks = []
+
+        # Check if thread still exists
+        thread_exists = any(
+            t.ident == thread_id and t.is_alive()
+            for t in threading.enumerate()
+        )
+
+        if not thread_exists:
+            checks.append(HealthCheck(
+                name=f"thread_{thread_info.thread_name}_alive",
+                status=HealthStatus.CRITICAL,
+                message=f"Thread {thread_info.thread_name} is no longer alive",
+                details={
+                    'thread_id': thread_id,
+                    'uptime': current_time - thread_info.start_time,
+                    'last_heartbeat': thread_info.last_heartbeat
+                },
+                recovery_action="restart_thread"
+            ))
+            return checks
+
+        # Check heartbeat freshness
+        heartbeat_age = current_time - thread_info.last_heartbeat
+
+        if heartbeat_age > self.heartbeat_timeout:
+            checks.append(HealthCheck(
+                name=f"thread_{thread_info.thread_name}_responsive",
+                status=HealthStatus.CRITICAL,
+                message=f"Thread {thread_info.thread_name} unresponsive for {heartbeat_age:.1f}s",
+                details={
+                    'thread_id': thread_id,
+                    'heartbeat_age': heartbeat_age,
+                    'heartbeat_count': thread_info.heartbeat_count,
+                    'last_activity': thread_info.last_activity,
+                    'is_responsive': thread_info.is_responsive
+                },
+                recovery_action="restart_thread"
+            ))
+        elif heartbeat_age > self.heartbeat_timeout * 0.5:  # Warning at 50% of timeout
+            checks.append(HealthCheck(
+                name=f"thread_{thread_info.thread_name}_responsive",
+                status=HealthStatus.WARNING,
+                message=f"Thread {thread_info.thread_name} slow heartbeat: {heartbeat_age:.1f}s",
+                details={
+                    'thread_id': thread_id,
+                    'heartbeat_age': heartbeat_age,
+                    'heartbeat_count': thread_info.heartbeat_count,
+                    'last_activity': thread_info.last_activity,
+                    'is_responsive': thread_info.is_responsive
+                }
+            ))
+
+        # Check responsiveness test results
+        if not thread_info.is_responsive:
+            checks.append(HealthCheck(
+                name=f"thread_{thread_info.thread_name}_callback",
+                status=HealthStatus.WARNING,
+                message=f"Thread {thread_info.thread_name} failed responsiveness test",
+                details={
+                    'thread_id': thread_id,
+                    'last_activity': thread_info.last_activity
+                }
+            ))
+
+        return checks
+
+
+# Global thread health monitor instance
+thread_health_monitor = ThreadHealthMonitor()
\ No newline at end of file
diff --git a/core/processes/__init__.py b/core/processes/__init__.py
deleted file mode 100644
index a04c152..0000000
--- a/core/processes/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-"""
-Session Process Management Module
-"""
\ No newline at end of file
diff --git a/core/processes/communication.py b/core/processes/communication.py
deleted file mode 100644
index 595e1fe..0000000
--- a/core/processes/communication.py
+++ /dev/null
@@ -1,317 +0,0 @@
-"""
-Inter-Process Communication (IPC) system for session processes.
-Defines message types and protocols for main ↔ session communication.
-"""
-
-import time
-from enum import Enum
-from typing import Dict, Any, Optional, Union
-from dataclasses import dataclass, field
-import numpy as np
-
-
-class MessageType(Enum):
-    """Message types for IPC communication."""
-
-    # Commands: Main → Session
-    INITIALIZE = "initialize"
-    PROCESS_FRAME = "process_frame"
-    SET_SESSION_ID = "set_session_id"
-    SHUTDOWN = "shutdown"
-    HEALTH_CHECK = "health_check"
-
-    # Responses: Session → Main
-    INITIALIZED = "initialized"
-    DETECTION_RESULT = "detection_result"
-    SESSION_SET = "session_set"
-    SHUTDOWN_COMPLETE = "shutdown_complete"
-    HEALTH_RESPONSE = "health_response"
-    ERROR = "error"
-
-
-@dataclass
-class IPCMessage:
-    """Base class for all IPC messages."""
-    type: MessageType
-    session_id: str
-    timestamp: float = field(default_factory=time.time)
-    message_id: str = field(default_factory=lambda: str(int(time.time() * 1000000)))
-
-
-@dataclass
-class InitializeCommand(IPCMessage):
-    """Initialize session process with configuration."""
-    subscription_config: Dict[str, Any] = field(default_factory=dict)
-    model_config: Dict[str, Any] = field(default_factory=dict)
-
-
-
-@dataclass
-class ProcessFrameCommand(IPCMessage):
-    """Process a frame through the detection pipeline."""
-    frame: Optional[np.ndarray] = None
-    display_id: str = ""
-    subscription_identifier: str = ""
-    frame_timestamp: float = 0.0
-
-
-
-@dataclass
-class SetSessionIdCommand(IPCMessage):
-    """Set the session ID for the current session."""
-    backend_session_id: str = ""
-    display_id: str = ""
-
-
-
-@dataclass
-class ShutdownCommand(IPCMessage):
-    """Shutdown the session process gracefully."""
-
-
-
-@dataclass
-class HealthCheckCommand(IPCMessage):
-    """Check health status of session process."""
-
-
-
-@dataclass
-class InitializedResponse(IPCMessage):
-    """Response indicating successful initialization."""
-    success: bool = False
-    error_message: Optional[str] = None
-
-
-
-@dataclass
-class DetectionResultResponse(IPCMessage):
-    """Detection results from session process."""
-    detections: Dict[str, Any] = field(default_factory=dict)
-    processing_time: float = 0.0
-    phase: str = ""  # "detection" or "processing"
-
-
-
-@dataclass
-class SessionSetResponse(IPCMessage):
-    """Response confirming session ID was set."""
-    success: bool = False
-    backend_session_id: str = ""
-
-
-
-@dataclass
-class ShutdownCompleteResponse(IPCMessage):
-    """Response confirming graceful shutdown."""
-
-
-
-@dataclass
-class HealthResponse(IPCMessage):
-    """Health status response."""
-    status: str = "unknown"  # "healthy", "degraded", "unhealthy"
-    memory_usage_mb: float = 0.0
-    cpu_percent: float = 0.0
-    gpu_memory_mb: Optional[float] = None
-    uptime_seconds: float = 0.0
-    processed_frames: int = 0
-
-
-
-@dataclass
-class ErrorResponse(IPCMessage):
-    """Error message from session process."""
-    error_type: str = ""
-    error_message: str = ""
-    traceback: Optional[str] = None
-
-
-
-# Type aliases for message unions
-CommandMessage = Union[
-    InitializeCommand,
-    ProcessFrameCommand,
-    SetSessionIdCommand,
-    ShutdownCommand,
-    HealthCheckCommand
-]
-
-ResponseMessage = Union[
-    InitializedResponse,
-    DetectionResultResponse,
-    SessionSetResponse,
-    ShutdownCompleteResponse,
-    HealthResponse,
-    ErrorResponse
-]
-
-IPCMessageUnion = Union[CommandMessage, ResponseMessage]
-
-
-class MessageSerializer:
-    """Handles serialization/deserialization of IPC messages."""
-
-    @staticmethod
-    def serialize_message(message: IPCMessageUnion) -> Dict[str, Any]:
-        """
-        Serialize message to dictionary for queue transport.
-
-        Args:
-            message: Message to serialize
-
-        Returns:
-            Dictionary representation of message
-        """
-        result = {
-            'type': message.type.value,
-            'session_id': message.session_id,
-            'timestamp': message.timestamp,
-            'message_id': message.message_id,
-        }
-
-        # Add specific fields based on message type
-        if isinstance(message, InitializeCommand):
-            result.update({
-                'subscription_config': message.subscription_config,
-                'model_config': message.model_config
-            })
-        elif isinstance(message, ProcessFrameCommand):
-            result.update({
-                'frame': message.frame,
-                'display_id': message.display_id,
-                'subscription_identifier': message.subscription_identifier,
-                'frame_timestamp': message.frame_timestamp
-            })
-        elif isinstance(message, SetSessionIdCommand):
-            result.update({
-                'backend_session_id': message.backend_session_id,
-                'display_id': message.display_id
-            })
-        elif isinstance(message, InitializedResponse):
-            result.update({
-                'success': message.success,
-                'error_message': message.error_message
-            })
-        elif isinstance(message, DetectionResultResponse):
-            result.update({
-                'detections': message.detections,
-                'processing_time': message.processing_time,
-                'phase': message.phase
-            })
-        elif isinstance(message, SessionSetResponse):
-            result.update({
-                'success': message.success,
-                'backend_session_id': message.backend_session_id
-            })
-        elif isinstance(message, HealthResponse):
-            result.update({
-                'status': message.status,
-                'memory_usage_mb': message.memory_usage_mb,
-                'cpu_percent': message.cpu_percent,
-                'gpu_memory_mb': message.gpu_memory_mb,
-                'uptime_seconds': message.uptime_seconds,
-                'processed_frames': message.processed_frames
-            })
-        elif isinstance(message, ErrorResponse):
-            result.update({
-                'error_type': message.error_type,
-                'error_message': message.error_message,
-                'traceback': message.traceback
-            })
-
-        return result
-
-    @staticmethod
-    def deserialize_message(data: Dict[str, Any]) -> IPCMessageUnion:
-        """
-        Deserialize dictionary back to message object.
-
-        Args:
-            data: Dictionary representation
-
-        Returns:
-            Deserialized message object
-        """
-        msg_type = MessageType(data['type'])
-        session_id = data['session_id']
-        timestamp = data['timestamp']
-        message_id = data['message_id']
-
-        base_kwargs = {
-            'session_id': session_id,
-            'timestamp': timestamp,
-            'message_id': message_id
-        }
-
-        if msg_type == MessageType.INITIALIZE:
-            return InitializeCommand(
-                type=msg_type,
-                subscription_config=data['subscription_config'],
-                model_config=data['model_config'],
-                **base_kwargs
-            )
-        elif msg_type == MessageType.PROCESS_FRAME:
-            return ProcessFrameCommand(
-                type=msg_type,
-                frame=data['frame'],
-                display_id=data['display_id'],
-                subscription_identifier=data['subscription_identifier'],
-                frame_timestamp=data['frame_timestamp'],
-                **base_kwargs
-            )
-        elif msg_type == MessageType.SET_SESSION_ID:
-            return SetSessionIdCommand(
-                backend_session_id=data['backend_session_id'],
-                display_id=data['display_id'],
-                **base_kwargs
-            )
-        elif msg_type == MessageType.SHUTDOWN:
-            return ShutdownCommand(**base_kwargs)
-        elif msg_type == MessageType.HEALTH_CHECK:
-            return HealthCheckCommand(**base_kwargs)
-        elif msg_type == MessageType.INITIALIZED:
-            return InitializedResponse(
-                type=msg_type,
-                success=data['success'],
-                error_message=data.get('error_message'),
-                **base_kwargs
-            )
-        elif msg_type == MessageType.DETECTION_RESULT:
-            return DetectionResultResponse(
-                type=msg_type,
-                detections=data['detections'],
-                processing_time=data['processing_time'],
-                phase=data['phase'],
-                **base_kwargs
-            )
-        elif msg_type == MessageType.SESSION_SET:
-            return SessionSetResponse(
-                type=msg_type,
-                success=data['success'],
-                backend_session_id=data['backend_session_id'],
-                **base_kwargs
-            )
-        elif msg_type == MessageType.SHUTDOWN_COMPLETE:
-            return ShutdownCompleteResponse(type=msg_type, **base_kwargs)
-        elif msg_type == MessageType.HEALTH_RESPONSE:
-            return HealthResponse(
-                type=msg_type,
-                status=data['status'],
-                memory_usage_mb=data['memory_usage_mb'],
-                cpu_percent=data['cpu_percent'],
-                gpu_memory_mb=data.get('gpu_memory_mb'),
-                uptime_seconds=data.get('uptime_seconds', 0.0),
-                processed_frames=data.get('processed_frames', 0),
-                **base_kwargs
-            )
-        elif msg_type == MessageType.ERROR:
-            return ErrorResponse(
-                type=msg_type,
-                error_type=data['error_type'],
-                error_message=data['error_message'],
-                traceback=data.get('traceback'),
-                **base_kwargs
-            )
-        else:
-            raise ValueError(f"Unknown message type: {msg_type}")
\ No newline at end of file
diff --git a/core/processes/session_manager.py b/core/processes/session_manager.py
deleted file mode 100644
index 60c575d..0000000
--- a/core/processes/session_manager.py
+++ /dev/null
@@ -1,464 +0,0 @@
-"""
-Session Process Manager - Manages lifecycle of session processes.
-Handles process spawning, monitoring, cleanup, and health checks.
-"""
-
-import time
-import logging
-import asyncio
-import multiprocessing as mp
-from typing import Dict, Optional, Any, Callable
-from dataclasses import dataclass
-from concurrent.futures import ThreadPoolExecutor
-import threading
-
-from .communication import (
-    MessageSerializer, MessageType,
-    InitializeCommand, ProcessFrameCommand, SetSessionIdCommand,
-    ShutdownCommand, HealthCheckCommand,
-    InitializedResponse, DetectionResultResponse, SessionSetResponse,
-    ShutdownCompleteResponse, HealthResponse, ErrorResponse
-)
-from .session_worker import session_worker_main
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class SessionProcessInfo:
-    """Information about a running session process."""
-    session_id: str
-    subscription_identifier: str
-    process: mp.Process
-    command_queue: mp.Queue
-    response_queue: mp.Queue
-    created_at: float
-    last_health_check: float = 0.0
-    is_initialized: bool = False
-    processed_frames: int = 0
-
-
-class SessionProcessManager:
-    """
-    Manages lifecycle of session processes.
-    Each session gets its own dedicated process for complete isolation.
-    """
-
-    def __init__(self, max_concurrent_sessions: int = 20, health_check_interval: int = 30):
-        """
-        Initialize session process manager.
-
-        Args:
-            max_concurrent_sessions: Maximum number of concurrent session processes
-            health_check_interval: Interval in seconds between health checks
-        """
-        self.max_concurrent_sessions = max_concurrent_sessions
-        self.health_check_interval = health_check_interval
-
-        # Active session processes
-        self.sessions: Dict[str, SessionProcessInfo] = {}
-        self.subscription_to_session: Dict[str, str] = {}
-
-        # Thread pool for response processing
-        self.response_executor = ThreadPoolExecutor(max_workers=4, thread_name_prefix="ResponseProcessor")
-
-        # Health check task
-        self.health_check_task = None
-        self.is_running = False
-
-        # Message callbacks
-        self.detection_result_callback: Optional[Callable] = None
-        self.error_callback: Optional[Callable] = None
-
-        # Store main event loop for async operations from threads
-        self.main_event_loop = None
-
-        logger.info(f"SessionProcessManager initialized (max_sessions={max_concurrent_sessions})")
-
-    async def start(self):
-        """Start the session process manager."""
-        if self.is_running:
-            return
-
-        self.is_running = True
-
-        # Store the main event loop for use in threads
-        self.main_event_loop = asyncio.get_running_loop()
-
-        logger.info("Starting session process manager")
-
-        # Start health check task
-        self.health_check_task = asyncio.create_task(self._health_check_loop())
-
-        # Start response processing for existing sessions
-        for session_info in self.sessions.values():
-            self._start_response_processing(session_info)
-
-    async def stop(self):
-        """Stop the session process manager and cleanup all sessions."""
-        if not self.is_running:
-            return
-
-        logger.info("Stopping session process manager")
-        self.is_running = False
-
-        # Cancel health check task
-        if self.health_check_task:
-            self.health_check_task.cancel()
-            try:
-                await self.health_check_task
-            except asyncio.CancelledError:
-                pass
-
-        # Shutdown all sessions
-        shutdown_tasks = []
-        for session_id in list(self.sessions.keys()):
-            task = asyncio.create_task(self.remove_session(session_id))
-            shutdown_tasks.append(task)
-
-        if shutdown_tasks:
-            await asyncio.gather(*shutdown_tasks, return_exceptions=True)
-
-        # Cleanup thread pool
-        self.response_executor.shutdown(wait=True)
-
-        logger.info("Session process manager stopped")
-
-    async def create_session(self, subscription_identifier: str, subscription_config: Dict[str, Any]) -> bool:
-        """
-        Create a new session process for a subscription.
-
-        Args:
-            subscription_identifier: Unique subscription identifier
-            subscription_config: Subscription configuration
-
-        Returns:
-            True if session was created successfully
-        """
-        try:
-            # Check if we're at capacity
-            if len(self.sessions) >= self.max_concurrent_sessions:
-                logger.warning(f"Cannot create session: at max capacity ({self.max_concurrent_sessions})")
-                return False
-
-            # Check if subscription already has a session
-            if subscription_identifier in self.subscription_to_session:
-                existing_session_id = self.subscription_to_session[subscription_identifier]
-                logger.info(f"Subscription {subscription_identifier} already has session {existing_session_id}")
-                return True
-
-            # Generate unique session ID
-            session_id = f"session_{int(time.time() * 1000)}_{subscription_identifier.replace(';', '_')}"
-
-            logger.info(f"Creating session process for subscription {subscription_identifier}")
-            logger.info(f"Session ID: {session_id}")
-
-            # Create communication queues
-            command_queue = mp.Queue()
-            response_queue = mp.Queue()
-
-            # Create and start process
-            process = mp.Process(
-                target=session_worker_main,
-                args=(session_id, command_queue, response_queue),
-                name=f"SessionWorker-{session_id}"
-            )
-            process.start()
-
-            # Store session information
-            session_info = SessionProcessInfo(
-                session_id=session_id,
-                subscription_identifier=subscription_identifier,
-                process=process,
-                command_queue=command_queue,
-                response_queue=response_queue,
-                created_at=time.time()
-            )
-
-            self.sessions[session_id] = session_info
-            self.subscription_to_session[subscription_identifier] = session_id
-
-            # Start response processing for this session
-            self._start_response_processing(session_info)
-
-            logger.info(f"Session process created: {session_id} (PID: {process.pid})")
-
-            # Initialize the session with configuration
-            model_config = {
-                'modelId': subscription_config.get('modelId'),
-                'modelUrl': subscription_config.get('modelUrl'),
-                'modelName': subscription_config.get('modelName')
-            }
-
-            init_command = InitializeCommand(
-                type=MessageType.INITIALIZE,
-                session_id=session_id,
-                subscription_config=subscription_config,
-                model_config=model_config
-            )
-
-            await self._send_command(session_id, init_command)
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to create session for {subscription_identifier}: {e}", exc_info=True)
-            # Cleanup on failure
-            if session_id in self.sessions:
-                await self._cleanup_session(session_id)
-            return False
-
-    async def remove_session(self, subscription_identifier: str) -> bool:
-        """
-        Remove a session process for a subscription.
-
-        Args:
-            subscription_identifier: Subscription identifier to remove
-
-        Returns:
-            True if session was removed successfully
-        """
-        try:
-            session_id = self.subscription_to_session.get(subscription_identifier)
-            if not session_id:
-                logger.warning(f"No session found for subscription {subscription_identifier}")
-                return False
-
-            logger.info(f"Removing session {session_id} for subscription {subscription_identifier}")
-
-            session_info = self.sessions.get(session_id)
-            if session_info:
-                # Send shutdown command
-                shutdown_command = ShutdownCommand(session_id=session_id)
-                await self._send_command(session_id, shutdown_command)
-
-                # Wait for graceful shutdown (with timeout)
-                try:
-                    await asyncio.wait_for(self._wait_for_shutdown(session_info), timeout=10.0)
-                except asyncio.TimeoutError:
-                    logger.warning(f"Session {session_id} did not shutdown gracefully, terminating")
-
-            # Cleanup session
-            await self._cleanup_session(session_id)
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to remove session for {subscription_identifier}: {e}", exc_info=True)
-            return False
-
-    async def process_frame(self, subscription_identifier: str, frame: Any, display_id: str, frame_timestamp: float) -> bool:
-        """
-        Send a frame to the session process for processing.
-
-        Args:
-            subscription_identifier: Subscription identifier
-            frame: Frame to process
-            display_id: Display identifier
-            frame_timestamp: Timestamp of the frame
-
-        Returns:
-            True if frame was sent successfully
-        """
-        try:
-            session_id = self.subscription_to_session.get(subscription_identifier)
-            if not session_id:
-                logger.warning(f"No session found for subscription {subscription_identifier}")
-                return False
-
-            session_info = self.sessions.get(session_id)
-            if not session_info or not session_info.is_initialized:
-                logger.warning(f"Session {session_id} not initialized")
-                return False
-
-            # Create process frame command
-            process_command = ProcessFrameCommand(
-                session_id=session_id,
-                frame=frame,
-                display_id=display_id,
-                subscription_identifier=subscription_identifier,
-                frame_timestamp=frame_timestamp
-            )
-
-            await self._send_command(session_id, process_command)
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to process frame for {subscription_identifier}: {e}", exc_info=True)
-            return False
-
-    async def set_session_id(self, subscription_identifier: str, backend_session_id: str, display_id: str) -> bool:
-        """
-        Set the backend session ID for a session.
-
-        Args:
-            subscription_identifier: Subscription identifier
-            backend_session_id: Backend session ID
-            display_id: Display identifier
-
-        Returns:
-            True if session ID was set successfully
-        """
-        try:
-            session_id = self.subscription_to_session.get(subscription_identifier)
-            if not session_id:
-                logger.warning(f"No session found for subscription {subscription_identifier}")
-                return False
-
-            # Create set session ID command
-            set_command = SetSessionIdCommand(
-                session_id=session_id,
-                backend_session_id=backend_session_id,
-                display_id=display_id
-            )
-
-            await self._send_command(session_id, set_command)
-            return True
-
-        except Exception as e:
-            logger.error(f"Failed to set session ID for {subscription_identifier}: {e}", exc_info=True)
-            return False
-
-    def set_detection_result_callback(self, callback: Callable):
-        """Set callback for handling detection results."""
-        self.detection_result_callback = callback
-
-    def set_error_callback(self, callback: Callable):
-        """Set callback for handling errors."""
-        self.error_callback = callback
-
-    def get_session_count(self) -> int:
-        """Get the number of active sessions."""
-        return len(self.sessions)
-
-    def get_session_info(self, subscription_identifier: str) -> Optional[Dict[str, Any]]:
-        """Get information about a session."""
-        session_id = self.subscription_to_session.get(subscription_identifier)
-        if not session_id:
-            return None
-
-        session_info = self.sessions.get(session_id)
-        if not session_info:
-            return None
-
-        return {
-            'session_id': session_id,
-            'subscription_identifier': subscription_identifier,
-            'created_at': session_info.created_at,
-            'is_initialized': session_info.is_initialized,
-            'processed_frames': session_info.processed_frames,
-            'process_pid': session_info.process.pid if session_info.process.is_alive() else None,
-            'is_alive': session_info.process.is_alive()
-        }
-
-    async def _send_command(self, session_id: str, command):
-        """Send command to session process."""
-        session_info = self.sessions.get(session_id)
-        if not session_info:
-            raise ValueError(f"Session {session_id} not found")
-
-        serialized = MessageSerializer.serialize_message(command)
-        session_info.command_queue.put(serialized)
-
-    def _start_response_processing(self, session_info: SessionProcessInfo):
-        """Start processing responses from a session process."""
-        def process_responses():
-            while session_info.session_id in self.sessions and session_info.process.is_alive():
-                try:
-                    if not session_info.response_queue.empty():
-                        response_data = session_info.response_queue.get(timeout=1.0)
-                        response = MessageSerializer.deserialize_message(response_data)
-                        if self.main_event_loop:
-                            asyncio.run_coroutine_threadsafe(
-                                self._handle_response(session_info.session_id, response),
-                                self.main_event_loop
-                            )
-                    else:
-                        time.sleep(0.01)
-                except Exception as e:
-                    logger.error(f"Error processing response from {session_info.session_id}: {e}")
-
-        self.response_executor.submit(process_responses)
-
-    async def _handle_response(self, session_id: str, response):
-        """Handle response from session process."""
-        try:
-            session_info = self.sessions.get(session_id)
-            if not session_info:
-                return
-
-            if response.type == MessageType.INITIALIZED:
-                session_info.is_initialized = response.success
-                if response.success:
-                    logger.info(f"Session {session_id} initialized successfully")
-                else:
-                    logger.error(f"Session {session_id} initialization failed: {response.error_message}")
-
-            elif response.type == MessageType.DETECTION_RESULT:
-                session_info.processed_frames += 1
-                if self.detection_result_callback:
-                    await self.detection_result_callback(session_info.subscription_identifier, response)
-
-            elif response.type == MessageType.SESSION_SET:
-                logger.info(f"Session ID set for {session_id}: {response.backend_session_id}")
-
-            elif response.type == MessageType.HEALTH_RESPONSE:
-                session_info.last_health_check = time.time()
-                logger.debug(f"Health check for {session_id}: {response.status}")
-
-            elif response.type == MessageType.ERROR:
-                logger.error(f"Error from session {session_id}: {response.error_message}")
-                if self.error_callback:
-                    await self.error_callback(session_info.subscription_identifier, response)
-
-        except Exception as e:
-            logger.error(f"Error handling response from {session_id}: {e}", exc_info=True)
-
-    async def _wait_for_shutdown(self, session_info: SessionProcessInfo):
-        """Wait for session process to shutdown gracefully."""
-        while session_info.process.is_alive():
-            await asyncio.sleep(0.1)
-
-    async def _cleanup_session(self, session_id: str):
-        """Cleanup session process and resources."""
-        try:
-            session_info = self.sessions.get(session_id)
-            if not session_info:
-                return
-
-            # Terminate process if still alive
-            if session_info.process.is_alive():
-                session_info.process.terminate()
-                # Wait a bit for graceful termination
-                await asyncio.sleep(1.0)
-                if session_info.process.is_alive():
-                    session_info.process.kill()
-
-            # Remove from tracking
-            del self.sessions[session_id]
-            if session_info.subscription_identifier in self.subscription_to_session:
-                del self.subscription_to_session[session_info.subscription_identifier]
-
-            logger.info(f"Session {session_id} cleaned up")
-
-        except Exception as e:
-            logger.error(f"Error cleaning up session {session_id}: {e}", exc_info=True)
-
-    async def _health_check_loop(self):
-        """Periodic health check of all session processes."""
-        while self.is_running:
-            try:
-                for session_id in list(self.sessions.keys()):
-                    session_info = self.sessions.get(session_id)
-                    if session_info and session_info.is_initialized:
-                        # Send health check
-                        health_command = HealthCheckCommand(session_id=session_id)
-                        await self._send_command(session_id, health_command)
-
-                await asyncio.sleep(self.health_check_interval)
-
-            except asyncio.CancelledError:
-                break
-            except Exception as e:
-                logger.error(f"Error in health check loop: {e}", exc_info=True)
-                await asyncio.sleep(5.0)  # Brief pause before retrying
\ No newline at end of file
diff --git a/core/processes/session_worker.py b/core/processes/session_worker.py
deleted file mode 100644
index ecc3530..0000000
--- a/core/processes/session_worker.py
+++ /dev/null
@@ -1,813 +0,0 @@
-"""
-Session Worker Process - Individual process that handles one session completely.
-Each camera/session gets its own dedicated worker process for complete isolation.
-"""
-
-import asyncio
-import multiprocessing as mp
-import time
-import logging
-import sys
-import os
-import traceback
-import psutil
-import threading
-import cv2
-import requests
-from typing import Dict, Any, Optional, Tuple
-from pathlib import Path
-import numpy as np
-from queue import Queue, Empty
-
-# Import core modules
-from ..models.manager import ModelManager
-from ..detection.pipeline import DetectionPipeline
-from ..models.pipeline import PipelineParser
-from ..logging.session_logger import PerSessionLogger
-from .communication import (
-    MessageSerializer, MessageType, IPCMessageUnion,
-    InitializeCommand, ProcessFrameCommand, SetSessionIdCommand,
-    ShutdownCommand, HealthCheckCommand,
-    InitializedResponse, DetectionResultResponse, SessionSetResponse,
-    ShutdownCompleteResponse, HealthResponse, ErrorResponse
-)
-
-
-class IntegratedStreamReader:
-    """
-    Integrated RTSP/HTTP stream reader for session worker processes.
-    Handles both RTSP streams and HTTP snapshots with automatic failover.
-    """
-
-    def __init__(self, session_id: str, subscription_config: Dict[str, Any], logger: logging.Logger):
-        self.session_id = session_id
-        self.subscription_config = subscription_config
-        self.logger = logger
-
-        # Stream configuration
-        self.rtsp_url = subscription_config.get('rtspUrl')
-        self.snapshot_url = subscription_config.get('snapshotUrl')
-        self.snapshot_interval = subscription_config.get('snapshotInterval', 2000) / 1000.0  # Convert to seconds
-
-        # Stream state
-        self.is_running = False
-        self.rtsp_cap = None
-        self.stream_thread = None
-        self.stop_event = threading.Event()
-
-        # Frame buffer - single latest frame only
-        self.frame_queue = Queue(maxsize=1)
-        self.last_frame_time = 0
-
-        # Stream health monitoring
-        self.consecutive_errors = 0
-        self.max_consecutive_errors = 30
-        self.reconnect_delay = 5.0
-        self.frame_timeout = 10.0  # Seconds without frame before considered dead
-
-        # Crop coordinates if present
-        self.crop_coords = None
-        if subscription_config.get('cropX1') is not None:
-            self.crop_coords = (
-                subscription_config['cropX1'],
-                subscription_config['cropY1'],
-                subscription_config['cropX2'],
-                subscription_config['cropY2']
-            )
-
-    def start(self) -> bool:
-        """Start the stream reading in background thread."""
-        if self.is_running:
-            return True
-
-        try:
-            self.is_running = True
-            self.stop_event.clear()
-
-            # Start background thread for stream reading
-            self.stream_thread = threading.Thread(
-                target=self._stream_loop,
-                name=f"StreamReader-{self.session_id}",
-                daemon=True
-            )
-            self.stream_thread.start()
-
-            self.logger.info(f"Stream reader started for {self.session_id}")
-            return True
-
-        except Exception as e:
-            self.logger.error(f"Failed to start stream reader: {e}")
-            self.is_running = False
-            return False
-
-    def stop(self):
-        """Stop the stream reading."""
-        if not self.is_running:
-            return
-
-        self.logger.info(f"Stopping stream reader for {self.session_id}")
-        self.is_running = False
-        self.stop_event.set()
-
-        # Close RTSP connection
-        if self.rtsp_cap:
-            try:
-                self.rtsp_cap.release()
-            except:
-                pass
-            self.rtsp_cap = None
-
-        # Wait for thread to finish
-        if self.stream_thread and self.stream_thread.is_alive():
-            self.stream_thread.join(timeout=3.0)
-
-    def get_latest_frame(self) -> Optional[Tuple[np.ndarray, str, float]]:
-        """Get the latest frame if available. Returns (frame, display_id, timestamp) or None."""
-        try:
-            # Non-blocking get - return None if no frame available
-            frame_data = self.frame_queue.get_nowait()
-            return frame_data
-        except Empty:
-            return None
-
-    def _stream_loop(self):
-        """Main stream reading loop - runs in background thread."""
-        self.logger.info(f"Stream loop started for {self.session_id}")
-
-        while self.is_running and not self.stop_event.is_set():
-            try:
-                if self.rtsp_url:
-                    # Try RTSP first
-                    self._read_rtsp_stream()
-                elif self.snapshot_url:
-                    # Fallback to HTTP snapshots
-                    self._read_http_snapshots()
-                else:
-                    self.logger.error("No stream URL configured")
-                    break
-
-            except Exception as e:
-                self.logger.error(f"Error in stream loop: {e}")
-                self._handle_stream_error()
-
-        self.logger.info(f"Stream loop ended for {self.session_id}")
-
-    def _read_rtsp_stream(self):
-        """Read frames from RTSP stream."""
-        if not self.rtsp_cap:
-            self._connect_rtsp()
-
-        if not self.rtsp_cap:
-            return
-
-        try:
-            ret, frame = self.rtsp_cap.read()
-
-            if ret and frame is not None:
-                # Process the frame
-                processed_frame = self._process_frame(frame)
-                if processed_frame is not None:
-                    # Extract display ID from subscription identifier
-                    display_id = self.subscription_config['subscriptionIdentifier'].split(';')[-1]
-                    timestamp = time.time()
-
-                    # Put frame in queue (replace if full)
-                    try:
-                        # Clear queue and put new frame
-                        try:
-                            self.frame_queue.get_nowait()
-                        except Empty:
-                            pass
-                        self.frame_queue.put((processed_frame, display_id, timestamp), timeout=0.1)
-                        self.last_frame_time = timestamp
-                        self.consecutive_errors = 0
-                    except:
-                        pass  # Queue full, skip frame
-            else:
-                self._handle_stream_error()
-
-        except Exception as e:
-            self.logger.error(f"Error reading RTSP frame: {e}")
-            self._handle_stream_error()
-
-    def _read_http_snapshots(self):
-        """Read frames from HTTP snapshot URL."""
-        try:
-            response = requests.get(self.snapshot_url, timeout=10)
-            response.raise_for_status()
-
-            # Convert response to numpy array
-            img_array = np.asarray(bytearray(response.content), dtype=np.uint8)
-            frame = cv2.imdecode(img_array, cv2.IMREAD_COLOR)
-
-            if frame is not None:
-                # Process the frame
-                processed_frame = self._process_frame(frame)
-                if processed_frame is not None:
-                    # Extract display ID from subscription identifier
-                    display_id = self.subscription_config['subscriptionIdentifier'].split(';')[-1]
-                    timestamp = time.time()
-
-                    # Put frame in queue (replace if full)
-                    try:
-                        # Clear queue and put new frame
-                        try:
-                            self.frame_queue.get_nowait()
-                        except Empty:
-                            pass
-                        self.frame_queue.put((processed_frame, display_id, timestamp), timeout=0.1)
-                        self.last_frame_time = timestamp
-                        self.consecutive_errors = 0
-                    except:
-                        pass  # Queue full, skip frame
-
-            # Wait for next snapshot interval
-            time.sleep(self.snapshot_interval)
-
-        except Exception as e:
-            self.logger.error(f"Error reading HTTP snapshot: {e}")
-            self._handle_stream_error()
-
-    def _connect_rtsp(self):
-        """Connect to RTSP stream."""
-        try:
-            self.logger.info(f"Connecting to RTSP: {self.rtsp_url}")
-
-            # Create VideoCapture with optimized settings
-            self.rtsp_cap = cv2.VideoCapture(self.rtsp_url)
-
-            # Set buffer size to 1 to reduce latency
-            self.rtsp_cap.set(cv2.CAP_PROP_BUFFERSIZE, 1)
-
-            # Check if connection successful
-            if self.rtsp_cap.isOpened():
-                # Test read a frame
-                ret, frame = self.rtsp_cap.read()
-                if ret and frame is not None:
-                    self.logger.info(f"RTSP connection successful for {self.session_id}")
-                    self.consecutive_errors = 0
-                    return True
-
-            # Connection failed
-            if self.rtsp_cap:
-                self.rtsp_cap.release()
-                self.rtsp_cap = None
-
-        except Exception as e:
-            self.logger.error(f"Failed to connect RTSP: {e}")
-
-        return False
-
-    def _process_frame(self, frame: np.ndarray) -> Optional[np.ndarray]:
-        """Process frame - apply cropping if configured."""
-        if frame is None:
-            return None
-
-        try:
-            # Apply crop if configured
-            if self.crop_coords:
-                x1, y1, x2, y2 = self.crop_coords
-                if x1 < x2 and y1 < y2:
-                    frame = frame[y1:y2, x1:x2]
-
-            return frame
-
-        except Exception as e:
-            self.logger.error(f"Error processing frame: {e}")
-            return None
-
-    def _handle_stream_error(self):
-        """Handle stream errors with reconnection logic."""
-        self.consecutive_errors += 1
-
-        if self.consecutive_errors >= self.max_consecutive_errors:
-            self.logger.error(f"Too many consecutive errors ({self.consecutive_errors}), stopping stream")
-            self.stop()
-            return
-
-        # Close current connection
-        if self.rtsp_cap:
-            try:
-                self.rtsp_cap.release()
-            except:
-                pass
-            self.rtsp_cap = None
-
-        # Wait before reconnecting
-        self.logger.warning(f"Stream error #{self.consecutive_errors}, reconnecting in {self.reconnect_delay}s")
-        time.sleep(self.reconnect_delay)
-
-    def is_healthy(self) -> bool:
-        """Check if stream is healthy (receiving frames)."""
-        if not self.is_running:
-            return False
-
-        # Check if we've received a frame recently
-        if self.last_frame_time > 0:
-            time_since_frame = time.time() - self.last_frame_time
-            return time_since_frame < self.frame_timeout
-
-        return False
-
-
-class SessionWorkerProcess:
-    """
-    Individual session worker process that handles one camera/session completely.
-    Runs in its own process with isolated memory, models, and state.
-    """
-
-    def __init__(self, session_id: str, command_queue: mp.Queue, response_queue: mp.Queue):
-        """
-        Initialize session worker process.
-
-        Args:
-            session_id: Unique session identifier
-            command_queue: Queue to receive commands from main process
-            response_queue: Queue to send responses back to main process
-        """
-        self.session_id = session_id
-        self.command_queue = command_queue
-        self.response_queue = response_queue
-
-        # Process information
-        self.process = None
-        self.start_time = time.time()
-        self.processed_frames = 0
-
-        # Session components (will be initialized in process)
-        self.model_manager = None
-        self.detection_pipeline = None
-        self.pipeline_parser = None
-        self.logger = None
-        self.session_logger = None
-        self.stream_reader = None
-
-        # Session state
-        self.subscription_config = None
-        self.model_config = None
-        self.backend_session_id = None
-        self.display_id = None
-        self.is_initialized = False
-        self.should_shutdown = False
-
-        # Frame processing
-        self.frame_processing_enabled = False
-
-    async def run(self):
-        """
-        Main entry point for the worker process.
-        This method runs in the separate process.
-        """
-        try:
-            # Set process name for debugging
-            mp.current_process().name = f"SessionWorker-{self.session_id}"
-
-            # Setup basic logging first (enhanced after we get subscription config)
-            self._setup_basic_logging()
-
-            self.logger.info(f"Session worker process started for session {self.session_id}")
-            self.logger.info(f"Process ID: {os.getpid()}")
-
-            # Main message processing loop with integrated frame processing
-            while not self.should_shutdown:
-                try:
-                    # Process pending messages
-                    await self._process_pending_messages()
-
-                    # Process frames if enabled and initialized
-                    if self.frame_processing_enabled and self.is_initialized and self.stream_reader:
-                        await self._process_stream_frames()
-
-                    # Brief sleep to prevent busy waiting
-                    await asyncio.sleep(0.01)
-
-                except Exception as e:
-                    self.logger.error(f"Error in main processing loop: {e}", exc_info=True)
-                    self._send_error_response("main_loop_error", str(e), traceback.format_exc())
-
-        except Exception as e:
-            # Critical error in main run loop
-            if self.logger:
-                self.logger.error(f"Critical error in session worker: {e}", exc_info=True)
-            else:
-                print(f"Critical error in session worker {self.session_id}: {e}")
-
-        finally:
-            # Cleanup stream reader
-            if self.stream_reader:
-                self.stream_reader.stop()
-
-            if self.session_logger:
-                self.session_logger.log_session_end()
-            if self.session_logger:
-                self.session_logger.cleanup()
-            if self.logger:
-                self.logger.info(f"Session worker process {self.session_id} shutting down")
-
-    async def _handle_message(self, message: IPCMessageUnion):
-        """
-        Handle incoming messages from main process.
-
-        Args:
-            message: Deserialized message object
-        """
-        try:
-            if message.type == MessageType.INITIALIZE:
-                await self._handle_initialize(message)
-            elif message.type == MessageType.PROCESS_FRAME:
-                await self._handle_process_frame(message)
-            elif message.type == MessageType.SET_SESSION_ID:
-                await self._handle_set_session_id(message)
-            elif message.type == MessageType.SHUTDOWN:
-                await self._handle_shutdown(message)
-            elif message.type == MessageType.HEALTH_CHECK:
-                await self._handle_health_check(message)
-            else:
-                self.logger.warning(f"Unknown message type: {message.type}")
-
-        except Exception as e:
-            self.logger.error(f"Error handling message {message.type}: {e}", exc_info=True)
-            self._send_error_response(f"handle_{message.type.value}_error", str(e), traceback.format_exc())
-
-    async def _handle_initialize(self, message: InitializeCommand):
-        """
-        Initialize the session with models and pipeline.
-
-        Args:
-            message: Initialize command message
-        """
-        try:
-            self.logger.info(f"Initializing session {self.session_id}")
-            self.logger.info(f"Subscription config: {message.subscription_config}")
-            self.logger.info(f"Model config: {message.model_config}")
-
-            # Store configuration
-            self.subscription_config = message.subscription_config
-            self.model_config = message.model_config
-
-            # Setup enhanced logging now that we have subscription config
-            self._setup_enhanced_logging()
-
-            # Initialize model manager (isolated for this process)
-            self.model_manager = ModelManager("models")
-            self.logger.info("Model manager initialized")
-
-            # Download and prepare model if needed
-            model_id = self.model_config.get('modelId')
-            model_url = self.model_config.get('modelUrl')
-            model_name = self.model_config.get('modelName', f'Model-{model_id}')
-
-            if model_id and model_url:
-                model_path = self.model_manager.ensure_model(model_id, model_url, model_name)
-                if not model_path:
-                    raise RuntimeError(f"Failed to download/prepare model {model_id}")
-
-                self.logger.info(f"Model {model_id} prepared at {model_path}")
-
-                # Log model loading
-                if self.session_logger:
-                    self.session_logger.log_model_loading(model_id, model_name, str(model_path))
-
-                # Load pipeline configuration
-                self.pipeline_parser = self.model_manager.get_pipeline_config(model_id)
-                if not self.pipeline_parser:
-                    raise RuntimeError(f"Failed to load pipeline config for model {model_id}")
-
-                self.logger.info(f"Pipeline configuration loaded for model {model_id}")
-
-                # Initialize detection pipeline (isolated for this session)
-                self.detection_pipeline = DetectionPipeline(
-                    pipeline_parser=self.pipeline_parser,
-                    model_manager=self.model_manager,
-                    model_id=model_id,
-                    message_sender=None  # Will be set to send via IPC
-                )
-
-                # Initialize pipeline components
-                if not await self.detection_pipeline.initialize():
-                    raise RuntimeError("Failed to initialize detection pipeline")
-
-                self.logger.info("Detection pipeline initialized successfully")
-
-                # Initialize integrated stream reader
-                self.logger.info("Initializing integrated stream reader")
-                self.stream_reader = IntegratedStreamReader(
-                    self.session_id,
-                    self.subscription_config,
-                    self.logger
-                )
-
-                # Start stream reading
-                if self.stream_reader.start():
-                    self.logger.info("Stream reader started successfully")
-                    self.frame_processing_enabled = True
-                else:
-                    self.logger.error("Failed to start stream reader")
-
-                self.is_initialized = True
-
-                # Send success response
-                response = InitializedResponse(
-                    type=MessageType.INITIALIZED,
-                    session_id=self.session_id,
-                    success=True
-                )
-                self._send_response(response)
-
-            else:
-                raise ValueError("Missing required model configuration (modelId, modelUrl)")
-
-        except Exception as e:
-            self.logger.error(f"Failed to initialize session: {e}", exc_info=True)
-            response = InitializedResponse(
-                type=MessageType.INITIALIZED,
-                session_id=self.session_id,
-                success=False,
-                error_message=str(e)
-            )
-            self._send_response(response)
-
-    async def _handle_process_frame(self, message: ProcessFrameCommand):
-        """
-        Process a frame through the detection pipeline.
-
-        Args:
-            message: Process frame command message
-        """
-        if not self.is_initialized:
-            self._send_error_response("not_initialized", "Session not initialized", None)
-            return
-
-        try:
-            self.logger.debug(f"Processing frame for display {message.display_id}")
-
-            # Process frame through detection pipeline
-            if self.backend_session_id:
-                # Processing phase (after session ID is set)
-                result = await self.detection_pipeline.execute_processing_phase(
-                    frame=message.frame,
-                    display_id=message.display_id,
-                    session_id=self.backend_session_id,
-                    subscription_id=message.subscription_identifier
-                )
-                phase = "processing"
-            else:
-                # Detection phase (before session ID is set)
-                result = await self.detection_pipeline.execute_detection_phase(
-                    frame=message.frame,
-                    display_id=message.display_id,
-                    subscription_id=message.subscription_identifier
-                )
-                phase = "detection"
-
-            self.processed_frames += 1
-
-            # Send result back to main process
-            response = DetectionResultResponse(
-                session_id=self.session_id,
-                detections=result,
-                processing_time=result.get('processing_time', 0.0),
-                phase=phase
-            )
-            self._send_response(response)
-
-        except Exception as e:
-            self.logger.error(f"Error processing frame: {e}", exc_info=True)
-            self._send_error_response("frame_processing_error", str(e), traceback.format_exc())
-
-    async def _handle_set_session_id(self, message: SetSessionIdCommand):
-        """
-        Set the backend session ID for this session.
-
-        Args:
-            message: Set session ID command message
-        """
-        try:
-            self.logger.info(f"Setting backend session ID: {message.backend_session_id}")
-            self.backend_session_id = message.backend_session_id
-            self.display_id = message.display_id
-
-            response = SessionSetResponse(
-                session_id=self.session_id,
-                success=True,
-                backend_session_id=message.backend_session_id
-            )
-            self._send_response(response)
-
-        except Exception as e:
-            self.logger.error(f"Error setting session ID: {e}", exc_info=True)
-            self._send_error_response("set_session_id_error", str(e), traceback.format_exc())
-
-    async def _handle_shutdown(self, message: ShutdownCommand):
-        """
-        Handle graceful shutdown request.
-
-        Args:
-            message: Shutdown command message
-        """
-        try:
-            self.logger.info("Received shutdown request")
-            self.should_shutdown = True
-
-            # Cleanup resources
-            if self.detection_pipeline:
-                # Add cleanup method to pipeline if needed
-                pass
-
-            response = ShutdownCompleteResponse(session_id=self.session_id)
-            self._send_response(response)
-
-        except Exception as e:
-            self.logger.error(f"Error during shutdown: {e}", exc_info=True)
-
-    async def _handle_health_check(self, message: HealthCheckCommand):
-        """
-        Handle health check request.
-
-        Args:
-            message: Health check command message
-        """
-        try:
-            # Get process metrics
-            process = psutil.Process()
-            memory_info = process.memory_info()
-            memory_mb = memory_info.rss / (1024 * 1024)  # Convert to MB
-            cpu_percent = process.cpu_percent()
-
-            # GPU memory (if available)
-            gpu_memory_mb = None
-            try:
-                import torch
-                if torch.cuda.is_available():
-                    gpu_memory_mb = torch.cuda.memory_allocated() / (1024 * 1024)
-            except ImportError:
-                pass
-
-            # Determine health status
-            status = "healthy"
-            if memory_mb > 2048:  # More than 2GB
-                status = "degraded"
-            if memory_mb > 4096:  # More than 4GB
-                status = "unhealthy"
-
-            response = HealthResponse(
-                session_id=self.session_id,
-                status=status,
-                memory_usage_mb=memory_mb,
-                cpu_percent=cpu_percent,
-                gpu_memory_mb=gpu_memory_mb,
-                uptime_seconds=time.time() - self.start_time,
-                processed_frames=self.processed_frames
-            )
-            self._send_response(response)
-
-        except Exception as e:
-            self.logger.error(f"Error checking health: {e}", exc_info=True)
-            self._send_error_response("health_check_error", str(e), traceback.format_exc())
-
-    def _send_response(self, response: IPCMessageUnion):
-        """
-        Send response message to main process.
-
-        Args:
-            response: Response message to send
-        """
-        try:
-            serialized = MessageSerializer.serialize_message(response)
-            self.response_queue.put(serialized)
-        except Exception as e:
-            if self.logger:
-                self.logger.error(f"Failed to send response: {e}")
-
-    def _send_error_response(self, error_type: str, error_message: str, traceback_str: Optional[str]):
-        """
-        Send error response to main process.
-
-        Args:
-            error_type: Type of error
-            error_message: Error message
-            traceback_str: Optional traceback string
-        """
-        error_response = ErrorResponse(
-            type=MessageType.ERROR,
-            session_id=self.session_id,
-            error_type=error_type,
-            error_message=error_message,
-            traceback=traceback_str
-        )
-        self._send_response(error_response)
-
-    def _setup_basic_logging(self):
-        """
-        Setup basic logging for this process before we have subscription config.
-        """
-        logging.basicConfig(
-            level=logging.INFO,
-            format=f"%(asctime)s [%(levelname)s] SessionWorker-{self.session_id}: %(message)s",
-            handlers=[
-                logging.StreamHandler(sys.stdout)
-            ]
-        )
-        self.logger = logging.getLogger(f"session_worker_{self.session_id}")
-
-    def _setup_enhanced_logging(self):
-        """
-        Setup per-session logging with dedicated log file after we have subscription config.
-        Phase 2: Enhanced logging with file rotation and session context.
-        """
-        if not self.subscription_config:
-            return
-
-        # Initialize per-session logger
-        subscription_id = self.subscription_config.get('subscriptionIdentifier', self.session_id)
-
-        self.session_logger = PerSessionLogger(
-            session_id=self.session_id,
-            subscription_identifier=subscription_id,
-            log_dir="logs",
-            max_size_mb=100,
-            backup_count=5
-        )
-
-        # Get the configured logger (replaces basic logger)
-        self.logger = self.session_logger.get_logger()
-
-        # Log session start
-        self.session_logger.log_session_start(os.getpid())
-
-    async def _process_pending_messages(self):
-        """Process pending IPC messages from main process."""
-        try:
-            # Process all pending messages
-            while not self.command_queue.empty():
-                message_data = self.command_queue.get_nowait()
-                message = MessageSerializer.deserialize_message(message_data)
-                await self._handle_message(message)
-        except Exception as e:
-            if not self.command_queue.empty():
-                # Only log error if there was actually a message to process
-                self.logger.error(f"Error processing messages: {e}", exc_info=True)
-
-    async def _process_stream_frames(self):
-        """Process frames from the integrated stream reader."""
-        try:
-            if not self.stream_reader or not self.stream_reader.is_running:
-                return
-
-            # Get latest frame from stream
-            frame_data = self.stream_reader.get_latest_frame()
-            if frame_data is None:
-                return
-
-            frame, display_id, timestamp = frame_data
-
-            # Process frame through detection pipeline
-            subscription_identifier = self.subscription_config['subscriptionIdentifier']
-
-            if self.backend_session_id:
-                # Processing phase (after session ID is set)
-                result = await self.detection_pipeline.execute_processing_phase(
-                    frame=frame,
-                    display_id=display_id,
-                    session_id=self.backend_session_id,
-                    subscription_id=subscription_identifier
-                )
-                phase = "processing"
-            else:
-                # Detection phase (before session ID is set)
-                result = await self.detection_pipeline.execute_detection_phase(
-                    frame=frame,
-                    display_id=display_id,
-                    subscription_id=subscription_identifier
-                )
-                phase = "detection"
-
-            self.processed_frames += 1
-
-            # Send result back to main process
-            response = DetectionResultResponse(
-                type=MessageType.DETECTION_RESULT,
-                session_id=self.session_id,
-                detections=result,
-                processing_time=result.get('processing_time', 0.0),
-                phase=phase
-            )
-            self._send_response(response)
-
-            # Log frame processing (debug level to avoid spam)
-            self.logger.debug(f"Processed frame #{self.processed_frames} from {display_id} (phase: {phase})")
-
-        except Exception as e:
-            self.logger.error(f"Error processing stream frame: {e}", exc_info=True)
-
-
-def session_worker_main(session_id: str, command_queue: mp.Queue, response_queue: mp.Queue):
-    """
-    Main entry point for session worker process.
-    This function is called when the process is spawned.
-    """
-    # Create worker instance
-    worker = SessionWorkerProcess(session_id, command_queue, response_queue)
-
-    # Run the worker
-    asyncio.run(worker.run())
\ No newline at end of file
diff --git a/core/streaming/__init__.py b/core/streaming/__init__.py
index c4c40dc..93005ab 100644
--- a/core/streaming/__init__.py
+++ b/core/streaming/__init__.py
@@ -2,14 +2,14 @@
 Streaming system for RTSP and HTTP camera feeds.
 Provides modular frame readers, buffers, and stream management.
 """
-from .readers import RTSPReader, HTTPSnapshotReader
+from .readers import HTTPSnapshotReader, FFmpegRTSPReader
 from .buffers import FrameBuffer, CacheBuffer, shared_frame_buffer, shared_cache_buffer
 from .manager import StreamManager, StreamConfig, SubscriptionInfo, shared_stream_manager, initialize_stream_manager
 
 __all__ = [
     # Readers
-    'RTSPReader',
     'HTTPSnapshotReader',
+    'FFmpegRTSPReader',
 
     # Buffers
     'FrameBuffer',
diff --git a/core/streaming/buffers.py b/core/streaming/buffers.py
index 602e028..f2c5787 100644
--- a/core/streaming/buffers.py
+++ b/core/streaming/buffers.py
@@ -9,53 +9,25 @@ import logging
 import numpy as np
 from typing import Optional, Dict, Any, Tuple
 from collections import defaultdict
-from enum import Enum
 
 
 logger = logging.getLogger(__name__)
 
 
-class StreamType(Enum):
-    """Stream type enumeration."""
-    RTSP = "rtsp"  # 1280x720 @ 6fps
-    HTTP = "http"  # 2560x1440 high quality
-
-
 class FrameBuffer:
-    """Thread-safe frame buffer optimized for different stream types."""
+    """Thread-safe frame buffer for all camera streams."""
 
     def __init__(self, max_age_seconds: int = 5):
         self.max_age_seconds = max_age_seconds
         self._frames: Dict[str, Dict[str, Any]] = {}
-        self._stream_types: Dict[str, StreamType] = {}
         self._lock = threading.RLock()
 
-        # Stream-specific settings
-        self.rtsp_config = {
-            'width': 1280,
-            'height': 720,
-            'fps': 6,
-            'max_size_mb': 3  # 1280x720x3 bytes = ~2.6MB
-        }
-        self.http_config = {
-            'width': 2560,
-            'height': 1440,
-            'max_size_mb': 10
-        }
-
-    def put_frame(self, camera_id: str, frame: np.ndarray, stream_type: Optional[StreamType] = None):
-        """Store a frame for the given camera ID with type-specific validation."""
+    def put_frame(self, camera_id: str, frame: np.ndarray):
+        """Store a frame for the given camera ID."""
         with self._lock:
-            # Detect stream type if not provided
-            if stream_type is None:
-                stream_type = self._detect_stream_type(frame)
-
-            # Store stream type
-            self._stream_types[camera_id] = stream_type
-
-            # Validate frame based on stream type
-            if not self._validate_frame(frame, stream_type):
-                logger.warning(f"Frame validation failed for camera {camera_id} ({stream_type.value})")
+            # Validate frame
+            if not self._validate_frame(frame):
+                logger.warning(f"Frame validation failed for camera {camera_id}")
                 return
 
             self._frames[camera_id] = {
@@ -63,14 +35,9 @@ class FrameBuffer:
                 'timestamp': time.time(),
                 'shape': frame.shape,
                 'dtype': str(frame.dtype),
-                'stream_type': stream_type.value,
                 'size_mb': frame.nbytes / (1024 * 1024)
             }
 
-            # Commented out verbose frame storage logging
-            # logger.debug(f"Stored {stream_type.value} frame for camera {camera_id}: "
-            #              f"{frame.shape[1]}x{frame.shape[0]}, {frame.nbytes / (1024 * 1024):.2f}MB")
-
     def get_frame(self, camera_id: str) -> Optional[np.ndarray]:
         """Get the latest frame for the given camera ID."""
         with self._lock:
@@ -79,15 +46,7 @@ class FrameBuffer:
 
             frame_data = self._frames[camera_id]
 
-            # Check if frame is too old
-            age = time.time() - frame_data['timestamp']
-            if age > self.max_age_seconds:
-                logger.debug(f"Frame for camera {camera_id} is {age:.1f}s old, discarding")
-                del self._frames[camera_id]
-                if camera_id in self._stream_types:
-                    del self._stream_types[camera_id]
-                return None
-
+            # Return frame regardless of age - frames persist until replaced
             return frame_data['frame'].copy()
 
     def get_frame_info(self, camera_id: str) -> Optional[Dict[str, Any]]:
@@ -99,18 +58,12 @@ class FrameBuffer:
             frame_data = self._frames[camera_id]
             age = time.time() - frame_data['timestamp']
 
-            if age > self.max_age_seconds:
-                del self._frames[camera_id]
-                if camera_id in self._stream_types:
-                    del self._stream_types[camera_id]
-                return None
-
+            # Return frame info regardless of age - frames persist until replaced
             return {
                 'timestamp': frame_data['timestamp'],
                 'age': age,
                 'shape': frame_data['shape'],
                 'dtype': frame_data['dtype'],
-                'stream_type': frame_data.get('stream_type', 'unknown'),
                 'size_mb': frame_data.get('size_mb', 0)
             }
 
@@ -123,8 +76,6 @@ class FrameBuffer:
         with self._lock:
             if camera_id in self._frames:
                 del self._frames[camera_id]
-            if camera_id in self._stream_types:
-                del self._stream_types[camera_id]
             logger.debug(f"Cleared frames for camera {camera_id}")
 
     def clear_all(self):
@@ -132,30 +83,13 @@ class FrameBuffer:
         with self._lock:
             count = len(self._frames)
             self._frames.clear()
-            self._stream_types.clear()
             logger.debug(f"Cleared all frames ({count} cameras)")
 
     def get_camera_list(self) -> list:
-        """Get list of cameras with valid frames."""
+        """Get list of cameras with frames - all frames persist until replaced."""
         with self._lock:
-            current_time = time.time()
-            valid_cameras = []
-            expired_cameras = []
-
-            for camera_id, frame_data in self._frames.items():
-                age = current_time - frame_data['timestamp']
-                if age <= self.max_age_seconds:
-                    valid_cameras.append(camera_id)
-                else:
-                    expired_cameras.append(camera_id)
-
-            # Clean up expired frames
-            for camera_id in expired_cameras:
-                del self._frames[camera_id]
-                if camera_id in self._stream_types:
-                    del self._stream_types[camera_id]
-
-            return valid_cameras
+            # Return all cameras that have frames - no age-based filtering
+            return list(self._frames.keys())
 
     def get_stats(self) -> Dict[str, Any]:
         """Get buffer statistics."""
@@ -163,104 +97,68 @@ class FrameBuffer:
             current_time = time.time()
             stats = {
                 'total_cameras': len(self._frames),
-                'valid_cameras': 0,
-                'expired_cameras': 0,
-                'rtsp_cameras': 0,
-                'http_cameras': 0,
+                'recent_cameras': 0,
+                'stale_cameras': 0,
                 'total_memory_mb': 0,
                 'cameras': {}
             }
 
             for camera_id, frame_data in self._frames.items():
                 age = current_time - frame_data['timestamp']
-                stream_type = frame_data.get('stream_type', 'unknown')
                 size_mb = frame_data.get('size_mb', 0)
 
+                # All frames are valid/available, but categorize by freshness for monitoring
                 if age <= self.max_age_seconds:
-                    stats['valid_cameras'] += 1
+                    stats['recent_cameras'] += 1
                 else:
-                    stats['expired_cameras'] += 1
-
-                if stream_type == StreamType.RTSP.value:
-                    stats['rtsp_cameras'] += 1
-                elif stream_type == StreamType.HTTP.value:
-                    stats['http_cameras'] += 1
+                    stats['stale_cameras'] += 1
 
                 stats['total_memory_mb'] += size_mb
 
                 stats['cameras'][camera_id] = {
                     'age': age,
-                    'valid': age <= self.max_age_seconds,
+                    'recent': age <= self.max_age_seconds,  # Recent but all frames available
                     'shape': frame_data['shape'],
                     'dtype': frame_data['dtype'],
-                    'stream_type': stream_type,
                     'size_mb': size_mb
                 }
 
             return stats
 
-    def _detect_stream_type(self, frame: np.ndarray) -> StreamType:
-        """Detect stream type based on frame dimensions."""
-        h, w = frame.shape[:2]
-
-        # Check if it matches RTSP dimensions (1280x720)
-        if w == self.rtsp_config['width'] and h == self.rtsp_config['height']:
-            return StreamType.RTSP
-
-        # Check if it matches HTTP dimensions (2560x1440) or close to it
-        if w >= 2000 and h >= 1000:
-            return StreamType.HTTP
-
-        # Default based on size
-        if w <= 1920 and h <= 1080:
-            return StreamType.RTSP
-        else:
-            return StreamType.HTTP
-
-    def _validate_frame(self, frame: np.ndarray, stream_type: StreamType) -> bool:
-        """Validate frame based on stream type."""
+    def _validate_frame(self, frame: np.ndarray) -> bool:
+        """Validate frame - basic validation for any stream type."""
         if frame is None or frame.size == 0:
             return False
 
         h, w = frame.shape[:2]
         size_mb = frame.nbytes / (1024 * 1024)
 
-        if stream_type == StreamType.RTSP:
-            config = self.rtsp_config
-            # Allow some tolerance for RTSP streams
-            if abs(w - config['width']) > 100 or abs(h - config['height']) > 100:
-                logger.warning(f"RTSP frame size mismatch: {w}x{h} (expected {config['width']}x{config['height']})")
-            if size_mb > config['max_size_mb']:
-                logger.warning(f"RTSP frame too large: {size_mb:.2f}MB (max {config['max_size_mb']}MB)")
-                return False
+        # Basic size validation - reject extremely large frames regardless of type
+        max_size_mb = 50  # Generous limit for any frame type
+        if size_mb > max_size_mb:
+            logger.warning(f"Frame too large: {size_mb:.2f}MB (max {max_size_mb}MB) for {w}x{h}")
+            return False
 
-        elif stream_type == StreamType.HTTP:
-            config = self.http_config
-            # More flexible for HTTP snapshots
-            if size_mb > config['max_size_mb']:
-                logger.warning(f"HTTP snapshot too large: {size_mb:.2f}MB (max {config['max_size_mb']}MB)")
-                return False
+        # Basic dimension validation
+        if w < 100 or h < 100:
+            logger.warning(f"Frame too small: {w}x{h}")
+            return False
 
         return True
 
 
 class CacheBuffer:
-    """Enhanced frame cache with support for cropping and optimized for different formats."""
+    """Enhanced frame cache with support for cropping."""
 
     def __init__(self, max_age_seconds: int = 10):
         self.frame_buffer = FrameBuffer(max_age_seconds)
         self._crop_cache: Dict[str, Dict[str, Any]] = {}
         self._cache_lock = threading.RLock()
+        self.jpeg_quality = 95  # High quality for all frames
 
-        # Quality settings for different stream types
-        self.jpeg_quality = {
-            StreamType.RTSP: 90,  # Good quality for 720p
-            StreamType.HTTP: 95   # High quality for 2K
-        }
-
-    def put_frame(self, camera_id: str, frame: np.ndarray, stream_type: Optional[StreamType] = None):
+    def put_frame(self, camera_id: str, frame: np.ndarray):
         """Store a frame and clear any associated crop cache."""
-        self.frame_buffer.put_frame(camera_id, frame, stream_type)
+        self.frame_buffer.put_frame(camera_id, frame)
 
         # Clear crop cache for this camera since we have a new frame
         with self._cache_lock:
@@ -325,21 +223,15 @@ class CacheBuffer:
 
     def get_frame_as_jpeg(self, camera_id: str, crop_coords: Optional[Tuple[int, int, int, int]] = None,
                           quality: Optional[int] = None) -> Optional[bytes]:
-        """Get frame as JPEG bytes with format-specific quality settings."""
+        """Get frame as JPEG bytes."""
         frame = self.get_frame(camera_id, crop_coords)
         if frame is None:
             return None
 
         try:
-            # Determine quality based on stream type if not specified
+            # Use specified quality or default
             if quality is None:
-                frame_info = self.frame_buffer.get_frame_info(camera_id)
-                if frame_info:
-                    stream_type_str = frame_info.get('stream_type', StreamType.RTSP.value)
-                    stream_type = StreamType.RTSP if stream_type_str == StreamType.RTSP.value else StreamType.HTTP
-                    quality = self.jpeg_quality[stream_type]
-                else:
-                    quality = 90  # Default
+                quality = self.jpeg_quality
 
             # Encode as JPEG with specified quality
             encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
diff --git a/core/streaming/manager.py b/core/streaming/manager.py
index 3e4e6f7..c4ebd77 100644
--- a/core/streaming/manager.py
+++ b/core/streaming/manager.py
@@ -1,40 +1,18 @@
 """
 Stream coordination and lifecycle management.
 Optimized for 1280x720@6fps RTSP and 2560x1440 HTTP snapshots.
-Supports both threading and multiprocessing modes for scalability.
 """
 import logging
 import threading
 import time
-import os
+import queue
+import asyncio
 from typing import Dict, Set, Optional, List, Any
 from dataclasses import dataclass
 from collections import defaultdict
 
-# Check if multiprocessing is enabled (default enabled with proper initialization)
-USE_MULTIPROCESSING = os.environ.get('USE_MULTIPROCESSING', 'true').lower() == 'true'
-
-logger = logging.getLogger(__name__)
-
-if USE_MULTIPROCESSING:
-    try:
-        from .process_manager import RTSPProcessManager, ProcessConfig
-        logger.info("Multiprocessing support enabled")
-        _mp_loaded = True
-    except ImportError as e:
-        logger.warning(f"Failed to load multiprocessing support: {e}")
-        USE_MULTIPROCESSING = False
-        _mp_loaded = False
-    except Exception as e:
-        logger.warning(f"Multiprocessing initialization failed: {e}")
-        USE_MULTIPROCESSING = False
-        _mp_loaded = False
-else:
-    logger.info("Multiprocessing support disabled (using threading mode)")
-    _mp_loaded = False
-
-from .readers import RTSPReader, HTTPSnapshotReader
-from .buffers import shared_cache_buffer, StreamType
+from .readers import HTTPSnapshotReader, FFmpegRTSPReader
+from .buffers import shared_cache_buffer
 from ..tracking.integration import TrackingPipelineIntegration
 
 
@@ -74,41 +52,64 @@ class StreamManager:
         self._camera_subscribers: Dict[str, Set[str]] = defaultdict(set)  # camera_id -> set of subscription_ids
         self._lock = threading.RLock()
 
-        # Initialize multiprocessing manager if enabled (lazy initialization)
-        self.process_manager = None
-        self._frame_getter_thread = None
-        self._multiprocessing_enabled = USE_MULTIPROCESSING and _mp_loaded
+        # Fair tracking queue system - per camera queues
+        self._tracking_queues: Dict[str, queue.Queue] = {}  # camera_id -> queue
+        self._tracking_workers = []
+        self._stop_workers = threading.Event()
+        self._dropped_frame_counts: Dict[str, int] = {}  # per-camera drop counts
 
-        if self._multiprocessing_enabled:
-            logger.info(f"Multiprocessing support enabled, will initialize on first use")
-        else:
-            logger.info(f"Multiprocessing support disabled, using threading mode")
+        # Round-robin scheduling state
+        self._camera_list = []  # Ordered list of active cameras
+        self._camera_round_robin_index = 0
+        self._round_robin_lock = threading.Lock()
 
-    def _initialize_multiprocessing(self) -> bool:
-        """Lazily initialize multiprocessing manager when first needed."""
-        if self.process_manager is not None:
-            return True
-
-        if not self._multiprocessing_enabled:
-            return False
-
-        try:
-            self.process_manager = RTSPProcessManager(max_processes=min(self.max_streams, 15))
-            # Start monitoring synchronously to ensure it's ready
-            self.process_manager.start_monitoring()
-            # Start frame getter thread
-            self._frame_getter_thread = threading.Thread(
-                target=self._multiprocess_frame_getter,
+        # Start worker threads for tracking processing
+        num_workers = min(4, max_streams // 2 + 1)  # Scale with streams
+        for i in range(num_workers):
+            worker = threading.Thread(
+                target=self._tracking_worker_loop,
+                name=f"TrackingWorker-{i}",
                 daemon=True
             )
-            self._frame_getter_thread.start()
-            logger.info(f"Initialized multiprocessing manager with max {self.process_manager.max_processes} processes")
-            return True
-        except Exception as e:
-            logger.error(f"Failed to initialize multiprocessing manager: {e}")
-            self.process_manager = None
-            self._multiprocessing_enabled = False  # Disable for future attempts
-            return False
+            worker.start()
+            self._tracking_workers.append(worker)
+
+        logger.info(f"Started {num_workers} tracking worker threads")
+
+    def _ensure_camera_queue(self, camera_id: str):
+        """Ensure a tracking queue exists for the camera."""
+        if camera_id not in self._tracking_queues:
+            self._tracking_queues[camera_id] = queue.Queue(maxsize=10)  # 10 frames per camera
+            self._dropped_frame_counts[camera_id] = 0
+
+            with self._round_robin_lock:
+                if camera_id not in self._camera_list:
+                    self._camera_list.append(camera_id)
+                    logger.info(f"Created tracking queue for camera {camera_id}")
+        else:
+            logger.debug(f"Camera {camera_id} already has tracking queue")
+
+    def _remove_camera_queue(self, camera_id: str):
+        """Remove tracking queue for a camera that's no longer active."""
+        if camera_id in self._tracking_queues:
+            # Clear any remaining items
+            while not self._tracking_queues[camera_id].empty():
+                try:
+                    self._tracking_queues[camera_id].get_nowait()
+                except queue.Empty:
+                    break
+
+            del self._tracking_queues[camera_id]
+            del self._dropped_frame_counts[camera_id]
+
+            with self._round_robin_lock:
+                if camera_id in self._camera_list:
+                    self._camera_list.remove(camera_id)
+                    # Reset index if needed
+                    if self._camera_round_robin_index >= len(self._camera_list):
+                        self._camera_round_robin_index = 0
+
+            logger.info(f"Removed tracking queue for camera {camera_id}")
 
     def add_subscription(self, subscription_id: str, stream_config: StreamConfig,
                         crop_coords: Optional[tuple] = None,
@@ -153,6 +154,10 @@ class StreamManager:
                 if not success:
                     self._remove_subscription_internal(subscription_id)
                     return False
+            else:
+                # Stream already exists, but ensure queue exists too
+                logger.info(f"Stream already exists for {camera_id}, ensuring queue exists")
+                self._ensure_camera_queue(camera_id)
 
             logger.info(f"Added subscription {subscription_id} for camera {camera_id} "
                        f"({len(self._camera_subscribers[camera_id])} total subscribers)")
@@ -189,25 +194,9 @@ class StreamManager:
         """Start a stream for the given camera."""
         try:
             if stream_config.rtsp_url:
-                # Try multiprocessing for RTSP if enabled
-                if self._multiprocessing_enabled and self._initialize_multiprocessing():
-                    config = ProcessConfig(
-                        camera_id=camera_id,
-                        rtsp_url=stream_config.rtsp_url,
-                        expected_fps=6,
-                        buffer_size=3,
-                        max_retries=stream_config.max_retries
-                    )
-                    success = self.process_manager.add_camera(config)
-                    if success:
-                        self._streams[camera_id] = 'multiprocessing'  # Mark as multiprocessing stream
-                        logger.info(f"Started RTSP multiprocessing stream for camera {camera_id}")
-                        return True
-                    else:
-                        logger.warning(f"Failed to start multiprocessing stream for {camera_id}, falling back to threading")
-
-                # Fall back to threading mode for RTSP
-                reader = RTSPReader(
+                # RTSP stream using FFmpeg subprocess with CUDA acceleration
+                logger.info(f"\033[94m[RTSP] Starting {camera_id}\033[0m")
+                reader = FFmpegRTSPReader(
                     camera_id=camera_id,
                     rtsp_url=stream_config.rtsp_url,
                     max_retries=stream_config.max_retries
@@ -215,10 +204,12 @@ class StreamManager:
                 reader.set_frame_callback(self._frame_callback)
                 reader.start()
                 self._streams[camera_id] = reader
-                logger.info(f"Started RTSP threading stream for camera {camera_id}")
+                self._ensure_camera_queue(camera_id)  # Create tracking queue
+                logger.info(f"\033[92m[RTSP] {camera_id} connected\033[0m")
 
             elif stream_config.snapshot_url:
-                # HTTP snapshot stream (always use threading)
+                # HTTP snapshot stream
+                logger.info(f"\033[95m[HTTP] Starting {camera_id}\033[0m")
                 reader = HTTPSnapshotReader(
                     camera_id=camera_id,
                     snapshot_url=stream_config.snapshot_url,
@@ -228,7 +219,8 @@ class StreamManager:
                 reader.set_frame_callback(self._frame_callback)
                 reader.start()
                 self._streams[camera_id] = reader
-                logger.info(f"Started HTTP snapshot stream for camera {camera_id}")
+                self._ensure_camera_queue(camera_id)  # Create tracking queue
+                logger.info(f"\033[92m[HTTP] {camera_id} connected\033[0m")
 
             else:
                 logger.error(f"No valid URL provided for camera {camera_id}")
@@ -244,69 +236,48 @@ class StreamManager:
         """Stop a stream for the given camera."""
         if camera_id in self._streams:
             try:
-                stream_obj = self._streams[camera_id]
-                if stream_obj == 'multiprocessing' and self.process_manager:
-                    # Remove from multiprocessing manager
-                    self.process_manager.remove_camera(camera_id)
-                    logger.info(f"Stopped multiprocessing stream for camera {camera_id}")
-                else:
-                    # Stop threading stream
-                    stream_obj.stop()
-                    logger.info(f"Stopped threading stream for camera {camera_id}")
-
+                self._streams[camera_id].stop()
                 del self._streams[camera_id]
-                shared_cache_buffer.clear_camera(camera_id)
+                self._remove_camera_queue(camera_id)  # Remove tracking queue
+                # DON'T clear frames - they should persist until replaced
+                # shared_cache_buffer.clear_camera(camera_id)  # REMOVED - frames should persist
+                logger.info(f"Stopped stream for camera {camera_id} (frames preserved in buffer)")
             except Exception as e:
                 logger.error(f"Error stopping stream for camera {camera_id}: {e}")
 
     def _frame_callback(self, camera_id: str, frame):
         """Callback for when a new frame is available."""
         try:
-            # Detect stream type based on frame dimensions
-            stream_type = self._detect_stream_type(frame)
+            # Store frame in shared buffer
+            shared_cache_buffer.put_frame(camera_id, frame)
+            # Quieter frame callback logging - only log occasionally
+            if hasattr(self, '_frame_log_count'):
+                self._frame_log_count += 1
+            else:
+                self._frame_log_count = 1
 
-            # Store frame in shared buffer with stream type
-            shared_cache_buffer.put_frame(camera_id, frame, stream_type)
+            # Log every 100 frames to avoid spam
+            if self._frame_log_count % 100 == 0:
+                available_cameras = shared_cache_buffer.frame_buffer.get_camera_list()
+                logger.info(f"\033[96m[BUFFER] {len(available_cameras)} active cameras: {', '.join(available_cameras)}\033[0m")
 
+            # Queue for tracking processing (non-blocking) - route to camera-specific queue
+            if camera_id in self._tracking_queues:
+                try:
+                    self._tracking_queues[camera_id].put_nowait({
+                        'frame': frame,
+                        'timestamp': time.time()
+                    })
+                except queue.Full:
+                    # Drop frame if camera queue is full (maintain real-time)
+                    self._dropped_frame_counts[camera_id] += 1
 
-            # Process tracking for subscriptions with tracking integration
-            self._process_tracking_for_camera(camera_id, frame)
+                    if self._dropped_frame_counts[camera_id] % 50 == 0:
+                        logger.warning(f"Dropped {self._dropped_frame_counts[camera_id]} frames for camera {camera_id} due to full queue")
 
         except Exception as e:
             logger.error(f"Error in frame callback for camera {camera_id}: {e}")
 
-    def _multiprocess_frame_getter(self):
-        """Background thread to get frames from multiprocessing manager."""
-        if not self.process_manager:
-            return
-
-        logger.info("Started multiprocessing frame getter thread")
-
-        while self.process_manager:
-            try:
-                # Get frames from all multiprocessing cameras
-                with self._lock:
-                    mp_cameras = [cid for cid, s in self._streams.items() if s == 'multiprocessing']
-
-                for camera_id in mp_cameras:
-                    try:
-                        result = self.process_manager.get_frame(camera_id)
-                        if result:
-                            frame, timestamp = result
-                            # Detect stream type and store in cache
-                            stream_type = self._detect_stream_type(frame)
-                            shared_cache_buffer.put_frame(camera_id, frame, stream_type)
-                            # Process tracking
-                            self._process_tracking_for_camera(camera_id, frame)
-                    except Exception as e:
-                        logger.debug(f"Error getting frame for {camera_id}: {e}")
-
-                time.sleep(0.05)  # 20 FPS polling rate
-
-            except Exception as e:
-                logger.error(f"Error in multiprocess frame getter: {e}")
-                time.sleep(1.0)
-
     def _process_tracking_for_camera(self, camera_id: str, frame):
         """Process tracking for all subscriptions of a camera."""
         try:
@@ -359,6 +330,134 @@ class StreamManager:
         except Exception as e:
             logger.error(f"Error processing tracking for camera {camera_id}: {e}")
 
+    def _tracking_worker_loop(self):
+        """Worker thread loop for round-robin processing of camera queues."""
+        logger.info(f"Tracking worker {threading.current_thread().name} started")
+
+        consecutive_empty = 0
+        max_consecutive_empty = 10  # Sleep if all cameras empty this many times
+
+        while not self._stop_workers.is_set():
+            try:
+                # Get next camera in round-robin fashion
+                camera_id, item = self._get_next_camera_item()
+
+                if camera_id is None:
+                    # No cameras have items, sleep briefly
+                    consecutive_empty += 1
+                    if consecutive_empty >= max_consecutive_empty:
+                        time.sleep(0.1)  # Sleep 100ms if nothing to process
+                        consecutive_empty = 0
+                    continue
+
+                consecutive_empty = 0  # Reset counter when we find work
+
+                frame = item['frame']
+                timestamp = item['timestamp']
+
+                # Check if frame is too old (drop if > 1 second old)
+                age = time.time() - timestamp
+                if age > 1.0:
+                    logger.debug(f"Dropping old frame for {camera_id} (age: {age:.2f}s)")
+                    continue
+
+                # Process tracking for this camera's frame
+                self._process_tracking_for_camera_sync(camera_id, frame)
+
+            except Exception as e:
+                logger.error(f"Error in tracking worker: {e}", exc_info=True)
+
+        logger.info(f"Tracking worker {threading.current_thread().name} stopped")
+
+    def _get_next_camera_item(self):
+        """Get next item from camera queues using round-robin scheduling."""
+        with self._round_robin_lock:
+            # Get current list of cameras from actual tracking queues (central state)
+            camera_list = list(self._tracking_queues.keys())
+
+            if not camera_list:
+                return None, None
+
+            attempts = 0
+            max_attempts = len(camera_list)
+
+            while attempts < max_attempts:
+                # Get current camera using round-robin index
+                if self._camera_round_robin_index >= len(camera_list):
+                    self._camera_round_robin_index = 0
+
+                camera_id = camera_list[self._camera_round_robin_index]
+
+                # Move to next camera for next call
+                self._camera_round_robin_index = (self._camera_round_robin_index + 1) % len(camera_list)
+
+                # Try to get item from this camera's queue
+                try:
+                    item = self._tracking_queues[camera_id].get_nowait()
+                    return camera_id, item
+                except queue.Empty:
+                    pass  # Try next camera
+
+                attempts += 1
+
+            return None, None  # All cameras empty
+
+    def _process_tracking_for_camera_sync(self, camera_id: str, frame):
+        """Synchronous version of tracking processing for worker threads."""
+        try:
+            with self._lock:
+                subscription_ids = list(self._camera_subscribers.get(camera_id, []))
+
+            for subscription_id in subscription_ids:
+                subscription_info = self._subscriptions.get(subscription_id)
+
+                if not subscription_info:
+                    logger.warning(f"No subscription info found for {subscription_id}")
+                    continue
+
+                if not subscription_info.tracking_integration:
+                    logger.debug(f"No tracking integration for {subscription_id} (camera {camera_id}), skipping inference")
+                    continue
+
+                display_id = subscription_id.split(';')[0] if ';' in subscription_id else subscription_id
+
+                try:
+                    # Run async tracking in thread's event loop
+                    loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(loop)
+                    try:
+                        result = loop.run_until_complete(
+                            subscription_info.tracking_integration.process_frame(
+                                frame, display_id, subscription_id
+                            )
+                        )
+
+                        # Log tracking results
+                        if result:
+                            tracked_count = len(result.get('tracked_vehicles', []))
+                            validated_vehicle = result.get('validated_vehicle')
+                            pipeline_result = result.get('pipeline_result')
+
+                            if tracked_count > 0:
+                                logger.info(f"[Tracking] {camera_id}: {tracked_count} vehicles tracked")
+
+                            if validated_vehicle:
+                                logger.info(f"[Tracking] {camera_id}: Vehicle {validated_vehicle['track_id']} "
+                                          f"validated as {validated_vehicle['state']} "
+                                          f"(confidence: {validated_vehicle['confidence']:.2f})")
+
+                            if pipeline_result:
+                                logger.info(f"[Pipeline] {camera_id}: {pipeline_result.get('status', 'unknown')} - "
+                                          f"{pipeline_result.get('message', 'no message')}")
+                    finally:
+                        loop.close()
+
+                except Exception as track_e:
+                    logger.error(f"Error in tracking for {subscription_id}: {track_e}")
+
+        except Exception as e:
+            logger.error(f"Error processing tracking for camera {camera_id}: {e}")
+
     def get_frame(self, camera_id: str, crop_coords: Optional[tuple] = None):
         """Get the latest frame for a camera with optional cropping."""
         return shared_cache_buffer.get_frame(camera_id, crop_coords)
@@ -474,17 +573,35 @@ class StreamManager:
 
     def stop_all(self):
         """Stop all streams and clear all subscriptions."""
+        # Signal workers to stop
+        self._stop_workers.set()
+
+        # Clear all camera queues
+        for camera_id, camera_queue in list(self._tracking_queues.items()):
+            while not camera_queue.empty():
+                try:
+                    camera_queue.get_nowait()
+                except queue.Empty:
+                    break
+
+        # Wait for workers to finish
+        for worker in self._tracking_workers:
+            worker.join(timeout=2.0)
+
+        # Clear queue management structures
+        self._tracking_queues.clear()
+        self._dropped_frame_counts.clear()
+        with self._round_robin_lock:
+            self._camera_list.clear()
+            self._camera_round_robin_index = 0
+
+        logger.info("Stopped all tracking worker threads")
+
         with self._lock:
             # Stop all streams
             for camera_id in list(self._streams.keys()):
                 self._stop_stream(camera_id)
 
-            # Stop multiprocessing manager if exists
-            if self.process_manager:
-                self.process_manager.stop_all()
-                self.process_manager = None
-                logger.info("Stopped multiprocessing manager")
-
             # Clear all tracking
             self._subscriptions.clear()
             self._camera_subscribers.clear()
@@ -494,29 +611,67 @@ class StreamManager:
 
     def set_session_id(self, display_id: str, session_id: str):
         """Set session ID for tracking integration."""
+        # Ensure session_id is always a string for consistent type handling
+        session_id = str(session_id) if session_id is not None else None
         with self._lock:
             for subscription_info in self._subscriptions.values():
                 # Check if this subscription matches the display_id
                 subscription_display_id = subscription_info.subscription_id.split(';')[0]
                 if subscription_display_id == display_id and subscription_info.tracking_integration:
-                    subscription_info.tracking_integration.set_session_id(display_id, session_id)
-                    logger.debug(f"Set session {session_id} for display {display_id}")
+                    # Pass the full subscription_id (displayId;cameraId) to the tracking integration
+                    subscription_info.tracking_integration.set_session_id(
+                        display_id,
+                        session_id,
+                        subscription_id=subscription_info.subscription_id
+                    )
+                    logger.debug(f"Set session {session_id} for display {display_id} with subscription {subscription_info.subscription_id}")
 
     def clear_session_id(self, session_id: str):
-        """Clear session ID from tracking integrations."""
+        """Clear session ID from the specific tracking integration handling this session."""
         with self._lock:
+            # Find the subscription that's handling this session
+            session_subscription = None
             for subscription_info in self._subscriptions.values():
                 if subscription_info.tracking_integration:
-                    subscription_info.tracking_integration.clear_session_id(session_id)
-                    logger.debug(f"Cleared session {session_id}")
+                    # Check if this integration is handling the given session_id
+                    integration = subscription_info.tracking_integration
+                    if session_id in integration.session_vehicles:
+                        session_subscription = subscription_info
+                        break
+
+            if session_subscription and session_subscription.tracking_integration:
+                session_subscription.tracking_integration.clear_session_id(session_id)
+                logger.debug(f"Cleared session {session_id} from subscription {session_subscription.subscription_id}")
+            else:
+                logger.warning(f"No tracking integration found for session {session_id}, broadcasting to all subscriptions")
+                # Fallback: broadcast to all (original behavior)
+                for subscription_info in self._subscriptions.values():
+                    if subscription_info.tracking_integration:
+                        subscription_info.tracking_integration.clear_session_id(session_id)
 
     def set_progression_stage(self, session_id: str, stage: str):
-        """Set progression stage for tracking integrations."""
+        """Set progression stage for the specific tracking integration handling this session."""
         with self._lock:
+            # Find the subscription that's handling this session
+            session_subscription = None
             for subscription_info in self._subscriptions.values():
                 if subscription_info.tracking_integration:
-                    subscription_info.tracking_integration.set_progression_stage(session_id, stage)
-                    logger.debug(f"Set progression stage for session {session_id}: {stage}")
+                    # Check if this integration is handling the given session_id
+                    # We need to check the integration's active sessions
+                    integration = subscription_info.tracking_integration
+                    if session_id in integration.session_vehicles:
+                        session_subscription = subscription_info
+                        break
+
+            if session_subscription and session_subscription.tracking_integration:
+                session_subscription.tracking_integration.set_progression_stage(session_id, stage)
+                logger.debug(f"Set progression stage for session {session_id}: {stage} on subscription {session_subscription.subscription_id}")
+            else:
+                logger.warning(f"No tracking integration found for session {session_id}, broadcasting to all subscriptions")
+                # Fallback: broadcast to all (original behavior)
+                for subscription_info in self._subscriptions.values():
+                    if subscription_info.tracking_integration:
+                        subscription_info.tracking_integration.set_progression_stage(session_id, stage)
 
     def get_tracking_stats(self) -> Dict[str, Any]:
         """Get tracking statistics from all subscriptions."""
@@ -527,26 +682,6 @@ class StreamManager:
                     stats[subscription_id] = subscription_info.tracking_integration.get_statistics()
         return stats
 
-    def _detect_stream_type(self, frame) -> StreamType:
-        """Detect stream type based on frame dimensions."""
-        if frame is None:
-            return StreamType.RTSP  # Default
-
-        h, w = frame.shape[:2]
-
-        # RTSP: 1280x720
-        if w == 1280 and h == 720:
-            return StreamType.RTSP
-
-        # HTTP: 2560x1440 or larger
-        if w >= 2000 and h >= 1000:
-            return StreamType.HTTP
-
-        # Default based on size
-        if w <= 1920 and h <= 1080:
-            return StreamType.RTSP
-        else:
-            return StreamType.HTTP
 
     def get_stats(self) -> Dict[str, Any]:
         """Get comprehensive streaming statistics."""
@@ -554,25 +689,11 @@ class StreamManager:
             buffer_stats = shared_cache_buffer.get_stats()
             tracking_stats = self.get_tracking_stats()
 
-            # Add stream type information
-            stream_types = {}
-            for camera_id in self._streams.keys():
-                stream_obj = self._streams[camera_id]
-                if stream_obj == 'multiprocessing':
-                    stream_types[camera_id] = 'rtsp_multiprocessing'
-                elif isinstance(stream_obj, RTSPReader):
-                    stream_types[camera_id] = 'rtsp_threading'
-                elif isinstance(stream_obj, HTTPSnapshotReader):
-                    stream_types[camera_id] = 'http'
-                else:
-                    stream_types[camera_id] = 'unknown'
-
             return {
                 'active_subscriptions': len(self._subscriptions),
                 'active_streams': len(self._streams),
                 'cameras_with_subscribers': len(self._camera_subscribers),
                 'max_streams': self.max_streams,
-                'stream_types': stream_types,
                 'subscriptions_by_camera': {
                     camera_id: len(subscribers)
                     for camera_id, subscribers in self._camera_subscribers.items()
diff --git a/core/streaming/process_manager.py b/core/streaming/process_manager.py
deleted file mode 100644
index d152861..0000000
--- a/core/streaming/process_manager.py
+++ /dev/null
@@ -1,453 +0,0 @@
-"""
-Multiprocessing-based RTSP stream management for scalability.
-Handles multiple camera streams using separate processes to bypass GIL limitations.
-"""
-
-import multiprocessing as mp
-import time
-import logging
-import cv2
-import numpy as np
-import queue
-import threading
-import os
-import psutil
-from typing import Dict, Optional, Tuple, Any, Callable
-from dataclasses import dataclass
-from multiprocessing import Process, Queue, Lock, Value, Array, Manager
-from multiprocessing.shared_memory import SharedMemory
-import signal
-import sys
-
-# Ensure proper multiprocessing context for uvicorn compatibility
-try:
-    mp.set_start_method('spawn', force=True)
-except RuntimeError:
-    pass  # Already set
-
-logger = logging.getLogger("detector_worker.process_manager")
-
-# Frame dimensions (1280x720 RGB)
-FRAME_WIDTH = 1280
-FRAME_HEIGHT = 720
-FRAME_CHANNELS = 3
-FRAME_SIZE = FRAME_WIDTH * FRAME_HEIGHT * FRAME_CHANNELS
-
-@dataclass
-class ProcessConfig:
-    """Configuration for camera process."""
-    camera_id: str
-    rtsp_url: str
-    expected_fps: int = 6
-    buffer_size: int = 3
-    max_retries: int = 30
-    reconnect_delay: float = 5.0
-
-
-class SharedFrameBuffer:
-    """Thread-safe shared memory frame buffer with double buffering."""
-
-    def __init__(self, camera_id: str):
-        self.camera_id = camera_id
-        self.lock = mp.Lock()
-
-        # Double buffering for lock-free reads
-        self.buffer_a = mp.Array('B', FRAME_SIZE, lock=False)
-        self.buffer_b = mp.Array('B', FRAME_SIZE, lock=False)
-
-        # Atomic index for current read buffer (0 or 1)
-        self.read_buffer_idx = mp.Value('i', 0)
-
-        # Frame metadata (atomic access)
-        self.timestamp = mp.Value('d', 0.0)
-        self.frame_number = mp.Value('L', 0)
-        self.is_valid = mp.Value('b', False)
-
-        # Statistics
-        self.frames_written = mp.Value('L', 0)
-        self.frames_dropped = mp.Value('L', 0)
-
-    def write_frame(self, frame: np.ndarray, timestamp: float) -> bool:
-        """Write frame to buffer with atomic swap."""
-        if frame is None or frame.size == 0:
-            return False
-
-        # Resize if needed
-        if frame.shape != (FRAME_HEIGHT, FRAME_WIDTH, FRAME_CHANNELS):
-            frame = cv2.resize(frame, (FRAME_WIDTH, FRAME_HEIGHT))
-
-        # Get write buffer (opposite of read buffer)
-        write_idx = 1 - self.read_buffer_idx.value
-        write_buffer = self.buffer_a if write_idx == 0 else self.buffer_b
-
-        try:
-            # Write to buffer without lock (safe because of double buffering)
-            frame_flat = frame.flatten()
-            write_buffer[:] = frame_flat.astype(np.uint8)
-
-            # Update metadata
-            self.timestamp.value = timestamp
-            self.frame_number.value += 1
-
-            # Atomic swap of buffers
-            with self.lock:
-                self.read_buffer_idx.value = write_idx
-                self.is_valid.value = True
-                self.frames_written.value += 1
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error writing frame for {self.camera_id}: {e}")
-            self.frames_dropped.value += 1
-            return False
-
-    def read_frame(self) -> Optional[Tuple[np.ndarray, float]]:
-        """Read frame from buffer without blocking writers."""
-        if not self.is_valid.value:
-            return None
-
-        # Get current read buffer index (atomic read)
-        read_idx = self.read_buffer_idx.value
-        read_buffer = self.buffer_a if read_idx == 0 else self.buffer_b
-
-        # Read timestamp (atomic)
-        timestamp = self.timestamp.value
-
-        # Copy frame data (no lock needed for read)
-        try:
-            frame_data = np.array(read_buffer, dtype=np.uint8)
-            frame = frame_data.reshape((FRAME_HEIGHT, FRAME_WIDTH, FRAME_CHANNELS))
-            return frame.copy(), timestamp
-        except Exception as e:
-            logger.error(f"Error reading frame for {self.camera_id}: {e}")
-            return None
-
-    def get_stats(self) -> Dict[str, int]:
-        """Get buffer statistics."""
-        return {
-            'frames_written': self.frames_written.value,
-            'frames_dropped': self.frames_dropped.value,
-            'frame_number': self.frame_number.value,
-            'is_valid': self.is_valid.value
-        }
-
-
-def camera_worker_process(
-    config: ProcessConfig,
-    frame_buffer: SharedFrameBuffer,
-    command_queue: Queue,
-    status_queue: Queue,
-    stop_event: mp.Event
-):
-    """
-    Worker process for individual camera stream.
-    Runs in separate process to bypass GIL.
-    """
-    # Set process name for debugging
-    mp.current_process().name = f"Camera-{config.camera_id}"
-
-    # Configure logging for subprocess
-    logging.basicConfig(
-        level=logging.INFO,
-        format=f'%(asctime)s [%(levelname)s] Camera-{config.camera_id}: %(message)s'
-    )
-
-    logger.info(f"Starting camera worker for {config.camera_id}")
-
-    cap = None
-    consecutive_errors = 0
-    frame_interval = 1.0 / config.expected_fps
-    last_frame_time = 0
-
-    def initialize_capture():
-        """Initialize OpenCV capture with optimized settings."""
-        nonlocal cap
-
-        try:
-            # Set RTSP transport to TCP for reliability
-            os.environ['OPENCV_FFMPEG_CAPTURE_OPTIONS'] = 'rtsp_transport;tcp'
-
-            # Create capture
-            cap = cv2.VideoCapture(config.rtsp_url, cv2.CAP_FFMPEG)
-
-            if not cap.isOpened():
-                logger.error(f"Failed to open RTSP stream")
-                return False
-
-            # Set capture properties
-            cap.set(cv2.CAP_PROP_FRAME_WIDTH, FRAME_WIDTH)
-            cap.set(cv2.CAP_PROP_FRAME_HEIGHT, FRAME_HEIGHT)
-            cap.set(cv2.CAP_PROP_FPS, config.expected_fps)
-            cap.set(cv2.CAP_PROP_BUFFERSIZE, config.buffer_size)
-
-            # Read initial frames to stabilize
-            for _ in range(3):
-                ret, _ = cap.read()
-                if not ret:
-                    logger.warning("Failed to read initial frames")
-                time.sleep(0.1)
-
-            logger.info(f"Successfully initialized capture")
-            return True
-
-        except Exception as e:
-            logger.error(f"Error initializing capture: {e}")
-            return False
-
-    # Main processing loop
-    while not stop_event.is_set():
-        try:
-            # Check for commands (non-blocking)
-            try:
-                command = command_queue.get_nowait()
-                if command == "reinit":
-                    logger.info("Received reinit command")
-                    if cap:
-                        cap.release()
-                        cap = None
-                    consecutive_errors = 0
-            except queue.Empty:
-                pass
-
-            # Initialize capture if needed
-            if cap is None or not cap.isOpened():
-                if not initialize_capture():
-                    time.sleep(config.reconnect_delay)
-                    consecutive_errors += 1
-                    if consecutive_errors > config.max_retries and config.max_retries > 0:
-                        logger.error("Max retries reached, exiting")
-                        break
-                    continue
-                else:
-                    consecutive_errors = 0
-
-            # Read frame with timing control
-            current_time = time.time()
-            if current_time - last_frame_time < frame_interval:
-                time.sleep(0.01)  # Small sleep to prevent busy waiting
-                continue
-
-            ret, frame = cap.read()
-
-            if not ret or frame is None:
-                consecutive_errors += 1
-
-                if consecutive_errors >= config.max_retries:
-                    logger.error(f"Too many consecutive errors ({consecutive_errors}), reinitializing")
-                    if cap:
-                        cap.release()
-                        cap = None
-                    consecutive_errors = 0
-                    time.sleep(config.reconnect_delay)
-                else:
-                    if consecutive_errors <= 5:
-                        logger.debug(f"Frame read failed (error {consecutive_errors})")
-                    elif consecutive_errors % 10 == 0:
-                        logger.warning(f"Continuing frame failures (error {consecutive_errors})")
-
-                    # Exponential backoff
-                    sleep_time = min(0.1 * (1.5 ** min(consecutive_errors, 10)), 1.0)
-                    time.sleep(sleep_time)
-                continue
-
-            # Frame read successful
-            consecutive_errors = 0
-            last_frame_time = current_time
-
-            # Write to shared buffer
-            if frame_buffer.write_frame(frame, current_time):
-                # Send status update periodically
-                if frame_buffer.frame_number.value % 30 == 0:  # Every 30 frames
-                    status_queue.put({
-                        'camera_id': config.camera_id,
-                        'status': 'running',
-                        'frames': frame_buffer.frame_number.value,
-                        'timestamp': current_time
-                    })
-
-        except KeyboardInterrupt:
-            logger.info("Received interrupt signal")
-            break
-        except Exception as e:
-            logger.error(f"Error in camera worker: {e}")
-            consecutive_errors += 1
-            time.sleep(1.0)
-
-    # Cleanup
-    if cap:
-        cap.release()
-
-    logger.info(f"Camera worker stopped")
-    status_queue.put({
-        'camera_id': config.camera_id,
-        'status': 'stopped',
-        'frames': frame_buffer.frame_number.value
-    })
-
-
-class RTSPProcessManager:
-    """
-    Manages multiple camera processes with health monitoring and auto-restart.
-    """
-
-    def __init__(self, max_processes: int = None):
-        self.max_processes = max_processes or (mp.cpu_count() - 2)
-        self.processes: Dict[str, Process] = {}
-        self.frame_buffers: Dict[str, SharedFrameBuffer] = {}
-        self.command_queues: Dict[str, Queue] = {}
-        self.status_queue = mp.Queue()
-        self.stop_events: Dict[str, mp.Event] = {}
-        self.configs: Dict[str, ProcessConfig] = {}
-
-        # Manager for shared objects
-        self.manager = Manager()
-        self.process_stats = self.manager.dict()
-
-        # Health monitoring thread
-        self.monitor_thread = None
-        self.monitor_stop = threading.Event()
-
-        logger.info(f"RTSPProcessManager initialized with max_processes={self.max_processes}")
-
-    def add_camera(self, config: ProcessConfig) -> bool:
-        """Add a new camera stream."""
-        if config.camera_id in self.processes:
-            logger.warning(f"Camera {config.camera_id} already exists")
-            return False
-
-        if len(self.processes) >= self.max_processes:
-            logger.error(f"Max processes ({self.max_processes}) reached")
-            return False
-
-        try:
-            # Create shared resources
-            frame_buffer = SharedFrameBuffer(config.camera_id)
-            command_queue = mp.Queue()
-            stop_event = mp.Event()
-
-            # Store resources
-            self.frame_buffers[config.camera_id] = frame_buffer
-            self.command_queues[config.camera_id] = command_queue
-            self.stop_events[config.camera_id] = stop_event
-            self.configs[config.camera_id] = config
-
-            # Start process
-            process = mp.Process(
-                target=camera_worker_process,
-                args=(config, frame_buffer, command_queue, self.status_queue, stop_event),
-                name=f"Camera-{config.camera_id}"
-            )
-            process.start()
-            self.processes[config.camera_id] = process
-
-            logger.info(f"Started process for camera {config.camera_id} (PID: {process.pid})")
-            return True
-
-        except Exception as e:
-            logger.error(f"Error adding camera {config.camera_id}: {e}")
-            self._cleanup_camera(config.camera_id)
-            return False
-
-    def remove_camera(self, camera_id: str) -> bool:
-        """Remove a camera stream."""
-        if camera_id not in self.processes:
-            return False
-
-        logger.info(f"Removing camera {camera_id}")
-
-        # Signal stop
-        if camera_id in self.stop_events:
-            self.stop_events[camera_id].set()
-
-        # Wait for process to stop
-        process = self.processes.get(camera_id)
-        if process and process.is_alive():
-            process.join(timeout=5.0)
-            if process.is_alive():
-                logger.warning(f"Force terminating process for {camera_id}")
-                process.terminate()
-                process.join(timeout=2.0)
-
-        # Cleanup
-        self._cleanup_camera(camera_id)
-        return True
-
-    def _cleanup_camera(self, camera_id: str):
-        """Clean up camera resources."""
-        for collection in [self.processes, self.frame_buffers,
-                          self.command_queues, self.stop_events, self.configs]:
-            collection.pop(camera_id, None)
-
-    def get_frame(self, camera_id: str) -> Optional[Tuple[np.ndarray, float]]:
-        """Get latest frame from camera."""
-        buffer = self.frame_buffers.get(camera_id)
-        if buffer:
-            return buffer.read_frame()
-        return None
-
-    def get_stats(self) -> Dict[str, Any]:
-        """Get statistics for all cameras."""
-        stats = {}
-        for camera_id, buffer in self.frame_buffers.items():
-            process = self.processes.get(camera_id)
-            stats[camera_id] = {
-                'buffer_stats': buffer.get_stats(),
-                'process_alive': process.is_alive() if process else False,
-                'process_pid': process.pid if process else None
-            }
-        return stats
-
-    def start_monitoring(self):
-        """Start health monitoring thread."""
-        if self.monitor_thread and self.monitor_thread.is_alive():
-            return
-
-        self.monitor_stop.clear()
-        self.monitor_thread = threading.Thread(target=self._monitor_processes)
-        self.monitor_thread.start()
-        logger.info("Started process monitoring")
-
-    def _monitor_processes(self):
-        """Monitor process health and restart if needed."""
-        while not self.monitor_stop.is_set():
-            try:
-                # Check status queue
-                try:
-                    while True:
-                        status = self.status_queue.get_nowait()
-                        self.process_stats[status['camera_id']] = status
-                except queue.Empty:
-                    pass
-
-                # Check process health
-                for camera_id in list(self.processes.keys()):
-                    process = self.processes.get(camera_id)
-                    if process and not process.is_alive():
-                        logger.warning(f"Process for {camera_id} died, restarting")
-                        config = self.configs.get(camera_id)
-                        if config:
-                            self.remove_camera(camera_id)
-                            time.sleep(1.0)
-                            self.add_camera(config)
-
-                time.sleep(5.0)  # Check every 5 seconds
-
-            except Exception as e:
-                logger.error(f"Error in monitor thread: {e}")
-                time.sleep(5.0)
-
-    def stop_all(self):
-        """Stop all camera processes."""
-        logger.info("Stopping all camera processes")
-
-        # Stop monitoring
-        if self.monitor_thread:
-            self.monitor_stop.set()
-            self.monitor_thread.join(timeout=5.0)
-
-        # Stop all cameras
-        for camera_id in list(self.processes.keys()):
-            self.remove_camera(camera_id)
-
-        logger.info("All processes stopped")
\ No newline at end of file
diff --git a/core/streaming/readers.py b/core/streaming/readers.py
deleted file mode 100644
index a5e25e3..0000000
--- a/core/streaming/readers.py
+++ /dev/null
@@ -1,508 +0,0 @@
-"""
-Frame readers for RTSP streams and HTTP snapshots.
-Optimized for 1280x720@6fps RTSP and 2560x1440 HTTP snapshots.
-
-NOTE: This module provides threading-based readers for fallback compatibility.
-For RTSP streams, the new multiprocessing implementation in process_manager.py
-is preferred and used by default for better scalability and performance.
-"""
-import cv2
-import logging
-import time
-import threading
-import requests
-import numpy as np
-import os
-from typing import Optional, Callable
-
-# Suppress FFMPEG/H.264 error messages if needed
-# Set this environment variable to reduce noise from decoder errors
-os.environ["OPENCV_LOG_LEVEL"] = "ERROR"
-os.environ["OPENCV_FFMPEG_LOGLEVEL"] = "-8"  # Suppress FFMPEG warnings
-
-logger = logging.getLogger(__name__)
-
-
-class RTSPReader:
-    """RTSP stream frame reader optimized for 1280x720 @ 6fps streams."""
-
-    def __init__(self, camera_id: str, rtsp_url: str, max_retries: int = 3):
-        self.camera_id = camera_id
-        self.rtsp_url = rtsp_url
-        self.max_retries = max_retries
-        self.cap = None
-        self.stop_event = threading.Event()
-        self.thread = None
-        self.frame_callback: Optional[Callable] = None
-
-        # Expected stream specifications
-        self.expected_width = 1280
-        self.expected_height = 720
-        self.expected_fps = 6
-
-        # Frame processing parameters
-        self.frame_interval = 1.0 / self.expected_fps  # ~167ms for 6fps
-        self.error_recovery_delay = 5.0  # Increased from 2.0 for stability
-        self.max_consecutive_errors = 30  # Increased from 10 to handle network jitter
-        self.stream_timeout = 30.0
-
-    def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
-        """Set callback function to handle captured frames."""
-        self.frame_callback = callback
-
-    def start(self):
-        """Start the RTSP reader thread."""
-        if self.thread and self.thread.is_alive():
-            logger.warning(f"RTSP reader for {self.camera_id} already running")
-            return
-
-        self.stop_event.clear()
-        self.thread = threading.Thread(target=self._read_frames, daemon=True)
-        self.thread.start()
-        logger.info(f"Started RTSP reader for camera {self.camera_id}")
-
-    def stop(self):
-        """Stop the RTSP reader thread."""
-        self.stop_event.set()
-        if self.thread:
-            self.thread.join(timeout=5.0)
-        if self.cap:
-            self.cap.release()
-        logger.info(f"Stopped RTSP reader for camera {self.camera_id}")
-
-    def _read_frames(self):
-        """Main frame reading loop with H.264 error recovery."""
-        consecutive_errors = 0
-        frame_count = 0
-        last_log_time = time.time()
-        last_successful_frame_time = time.time()
-        last_frame_time = 0
-
-        while not self.stop_event.is_set():
-            try:
-                # Initialize/reinitialize capture if needed
-                if not self.cap or not self.cap.isOpened():
-                    if not self._initialize_capture():
-                        time.sleep(self.error_recovery_delay)
-                        continue
-                    last_successful_frame_time = time.time()
-
-                # Check for stream timeout
-                if time.time() - last_successful_frame_time > self.stream_timeout:
-                    logger.warning(f"Camera {self.camera_id}: Stream timeout, reinitializing")
-                    self._reinitialize_capture()
-                    last_successful_frame_time = time.time()
-                    continue
-
-                # Rate limiting for 6fps
-                current_time = time.time()
-                if current_time - last_frame_time < self.frame_interval:
-                    time.sleep(0.01)  # Small sleep to avoid busy waiting
-                    continue
-
-                ret, frame = self.cap.read()
-
-                if not ret or frame is None:
-                    consecutive_errors += 1
-
-                    if consecutive_errors >= self.max_consecutive_errors:
-                        logger.error(f"Camera {self.camera_id}: Too many consecutive errors, reinitializing")
-                        self._reinitialize_capture()
-                        consecutive_errors = 0
-                        time.sleep(self.error_recovery_delay)
-                    else:
-                        # Skip corrupted frame and continue with exponential backoff
-                        if consecutive_errors <= 5:
-                            logger.debug(f"Camera {self.camera_id}: Frame read failed (error {consecutive_errors})")
-                        elif consecutive_errors % 10 == 0:  # Log every 10th error after 5
-                            logger.warning(f"Camera {self.camera_id}: Continuing frame read failures (error {consecutive_errors})")
-
-                        # Exponential backoff with cap at 1 second
-                        sleep_time = min(0.1 * (1.5 ** min(consecutive_errors, 10)), 1.0)
-                        time.sleep(sleep_time)
-                    continue
-
-                # Validate frame dimensions
-                if frame.shape[1] != self.expected_width or frame.shape[0] != self.expected_height:
-                    logger.warning(f"Camera {self.camera_id}: Unexpected frame dimensions {frame.shape[1]}x{frame.shape[0]}")
-                    # Try to resize if dimensions are wrong
-                    if frame.shape[1] > 0 and frame.shape[0] > 0:
-                        frame = cv2.resize(frame, (self.expected_width, self.expected_height))
-                    else:
-                        consecutive_errors += 1
-                        continue
-
-                # Check for corrupted frames (all black, all white, excessive noise)
-                if self._is_frame_corrupted(frame):
-                    logger.debug(f"Camera {self.camera_id}: Corrupted frame detected, skipping")
-                    consecutive_errors += 1
-                    continue
-
-                # Frame is valid
-                consecutive_errors = 0
-                frame_count += 1
-                last_successful_frame_time = time.time()
-                last_frame_time = current_time
-
-                # Call frame callback
-                if self.frame_callback:
-                    try:
-                        self.frame_callback(self.camera_id, frame)
-                    except Exception as e:
-                        logger.error(f"Camera {self.camera_id}: Frame callback error: {e}")
-
-                # Log progress every 30 seconds
-                if current_time - last_log_time >= 30:
-                    logger.info(f"Camera {self.camera_id}: {frame_count} frames processed")
-                    last_log_time = current_time
-
-            except Exception as e:
-                logger.error(f"Camera {self.camera_id}: Error in frame reading loop: {e}")
-                consecutive_errors += 1
-                if consecutive_errors >= self.max_consecutive_errors:
-                    self._reinitialize_capture()
-                    consecutive_errors = 0
-                time.sleep(self.error_recovery_delay)
-
-        # Cleanup
-        if self.cap:
-            self.cap.release()
-        logger.info(f"RTSP reader thread ended for camera {self.camera_id}")
-
-    def _initialize_capture(self) -> bool:
-        """Initialize video capture with optimized settings for 1280x720@6fps."""
-        try:
-            # Release previous capture if exists
-            if self.cap:
-                self.cap.release()
-                time.sleep(0.5)
-
-            logger.info(f"Initializing capture for camera {self.camera_id}")
-
-            # Create capture with FFMPEG backend and TCP transport for reliability
-            # Use TCP instead of UDP to prevent packet loss
-            rtsp_url_tcp = self.rtsp_url.replace('rtsp://', 'rtsp://')
-            if '?' in rtsp_url_tcp:
-                rtsp_url_tcp += '&tcp'
-            else:
-                rtsp_url_tcp += '?tcp'
-
-            # Alternative: Set environment variable for RTSP transport
-            import os
-            os.environ['OPENCV_FFMPEG_CAPTURE_OPTIONS'] = 'rtsp_transport;tcp'
-
-            self.cap = cv2.VideoCapture(self.rtsp_url, cv2.CAP_FFMPEG)
-
-            if not self.cap.isOpened():
-                logger.error(f"Failed to open stream for camera {self.camera_id}")
-                return False
-
-            # Set capture properties for 1280x720@6fps
-            self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.expected_width)
-            self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.expected_height)
-            self.cap.set(cv2.CAP_PROP_FPS, self.expected_fps)
-
-            # Set moderate buffer to handle network jitter while avoiding excessive latency
-            # Buffer of 3 frames provides resilience without major delay
-            self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 3)
-
-            # Set FFMPEG options for better H.264 handling
-            self.cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*'H264'))
-
-            # Verify stream properties
-            actual_width = int(self.cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-            actual_height = int(self.cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-            actual_fps = self.cap.get(cv2.CAP_PROP_FPS)
-
-            logger.info(f"Camera {self.camera_id} initialized: {actual_width}x{actual_height} @ {actual_fps}fps")
-
-            # Read and discard first few frames to stabilize stream
-            for _ in range(5):
-                ret, _ = self.cap.read()
-                if not ret:
-                    logger.warning(f"Camera {self.camera_id}: Failed to read initial frames")
-                time.sleep(0.1)
-
-            return True
-
-        except Exception as e:
-            logger.error(f"Error initializing capture for camera {self.camera_id}: {e}")
-            return False
-
-    def _reinitialize_capture(self):
-        """Reinitialize capture after errors with retry logic."""
-        logger.info(f"Reinitializing capture for camera {self.camera_id}")
-        if self.cap:
-            self.cap.release()
-            self.cap = None
-
-        # Longer delay before reconnection to avoid rapid reconnect loops
-        time.sleep(3.0)
-
-        # Retry initialization up to 3 times
-        for attempt in range(3):
-            if self._initialize_capture():
-                logger.info(f"Successfully reinitialized camera {self.camera_id} on attempt {attempt + 1}")
-                break
-            else:
-                logger.warning(f"Failed to reinitialize camera {self.camera_id} on attempt {attempt + 1}")
-                time.sleep(2.0)
-
-    def _is_frame_corrupted(self, frame: np.ndarray) -> bool:
-        """Check if frame is corrupted (all black, all white, or excessive noise)."""
-        if frame is None or frame.size == 0:
-            return True
-
-        # Check mean and standard deviation
-        mean = np.mean(frame)
-        std = np.std(frame)
-
-        # All black or all white
-        if mean < 5 or mean > 250:
-            return True
-
-        # No variation (stuck frame)
-        if std < 1:
-            return True
-
-        # Excessive noise (corrupted H.264 decode)
-        # Calculate edge density as corruption indicator
-        edges = cv2.Canny(frame, 50, 150)
-        edge_density = np.sum(edges > 0) / edges.size
-
-        # Too many edges indicate corruption
-        if edge_density > 0.5:
-            return True
-
-        return False
-
-
-class HTTPSnapshotReader:
-    """HTTP snapshot reader optimized for 2560x1440 (2K) high quality images."""
-
-    def __init__(self, camera_id: str, snapshot_url: str, interval_ms: int = 5000, max_retries: int = 3):
-        self.camera_id = camera_id
-        self.snapshot_url = snapshot_url
-        self.interval_ms = interval_ms
-        self.max_retries = max_retries
-        self.stop_event = threading.Event()
-        self.thread = None
-        self.frame_callback: Optional[Callable] = None
-
-        # Expected snapshot specifications
-        self.expected_width = 2560
-        self.expected_height = 1440
-        self.max_file_size = 10 * 1024 * 1024  # 10MB max for 2K image
-
-    def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
-        """Set callback function to handle captured frames."""
-        self.frame_callback = callback
-
-    def start(self):
-        """Start the snapshot reader thread."""
-        if self.thread and self.thread.is_alive():
-            logger.warning(f"Snapshot reader for {self.camera_id} already running")
-            return
-
-        self.stop_event.clear()
-        self.thread = threading.Thread(target=self._read_snapshots, daemon=True)
-        self.thread.start()
-        logger.info(f"Started snapshot reader for camera {self.camera_id}")
-
-    def stop(self):
-        """Stop the snapshot reader thread."""
-        self.stop_event.set()
-        if self.thread:
-            self.thread.join(timeout=5.0)
-        logger.info(f"Stopped snapshot reader for camera {self.camera_id}")
-
-    def _read_snapshots(self):
-        """Main snapshot reading loop for high quality 2K images."""
-        retries = 0
-        frame_count = 0
-        last_log_time = time.time()
-        interval_seconds = self.interval_ms / 1000.0
-
-        logger.info(f"Snapshot interval for camera {self.camera_id}: {interval_seconds}s")
-
-        while not self.stop_event.is_set():
-            try:
-                start_time = time.time()
-                frame = self._fetch_snapshot()
-
-                if frame is None:
-                    retries += 1
-                    logger.warning(f"Failed to fetch snapshot for camera {self.camera_id}, retry {retries}/{self.max_retries}")
-
-                    if self.max_retries != -1 and retries > self.max_retries:
-                        logger.error(f"Max retries reached for snapshot camera {self.camera_id}")
-                        break
-
-                    time.sleep(min(2.0, interval_seconds))
-                    continue
-
-                # Validate image dimensions
-                if frame.shape[1] != self.expected_width or frame.shape[0] != self.expected_height:
-                    logger.info(f"Camera {self.camera_id}: Snapshot dimensions {frame.shape[1]}x{frame.shape[0]} "
-                               f"(expected {self.expected_width}x{self.expected_height})")
-                    # Resize if needed (maintaining aspect ratio for high quality)
-                    if frame.shape[1] > 0 and frame.shape[0] > 0:
-                        # Only resize if significantly different
-                        if abs(frame.shape[1] - self.expected_width) > 100:
-                            frame = self._resize_maintain_aspect(frame, self.expected_width, self.expected_height)
-
-                # Reset retry counter on successful fetch
-                retries = 0
-                frame_count += 1
-
-                # Call frame callback
-                if self.frame_callback:
-                    try:
-                        self.frame_callback(self.camera_id, frame)
-                    except Exception as e:
-                        logger.error(f"Camera {self.camera_id}: Frame callback error: {e}")
-
-                # Log progress every 30 seconds
-                current_time = time.time()
-                if current_time - last_log_time >= 30:
-                    logger.info(f"Camera {self.camera_id}: {frame_count} snapshots processed")
-                    last_log_time = current_time
-
-                # Wait for next interval
-                elapsed = time.time() - start_time
-                sleep_time = max(0, interval_seconds - elapsed)
-                if sleep_time > 0:
-                    self.stop_event.wait(sleep_time)
-
-            except Exception as e:
-                logger.error(f"Error in snapshot loop for camera {self.camera_id}: {e}")
-                retries += 1
-                if self.max_retries != -1 and retries > self.max_retries:
-                    break
-                time.sleep(min(2.0, interval_seconds))
-
-        logger.info(f"Snapshot reader thread ended for camera {self.camera_id}")
-
-    def _fetch_snapshot(self) -> Optional[np.ndarray]:
-        """Fetch a single high quality snapshot from HTTP URL."""
-        try:
-            # Parse URL for authentication
-            from urllib.parse import urlparse
-            parsed_url = urlparse(self.snapshot_url)
-
-            headers = {
-                'User-Agent': 'Python-Detector-Worker/1.0',
-                'Accept': 'image/jpeg, image/png, image/*'
-            }
-            auth = None
-
-            if parsed_url.username and parsed_url.password:
-                from requests.auth import HTTPBasicAuth, HTTPDigestAuth
-                auth = HTTPBasicAuth(parsed_url.username, parsed_url.password)
-
-                # Reconstruct URL without credentials
-                clean_url = f"{parsed_url.scheme}://{parsed_url.hostname}"
-                if parsed_url.port:
-                    clean_url += f":{parsed_url.port}"
-                clean_url += parsed_url.path
-                if parsed_url.query:
-                    clean_url += f"?{parsed_url.query}"
-
-                # Try Basic Auth first
-                response = requests.get(clean_url, auth=auth, timeout=15, headers=headers,
-                                       stream=True, verify=False)
-
-                # If Basic Auth fails, try Digest Auth
-                if response.status_code == 401:
-                    auth = HTTPDigestAuth(parsed_url.username, parsed_url.password)
-                    response = requests.get(clean_url, auth=auth, timeout=15, headers=headers,
-                                          stream=True, verify=False)
-            else:
-                response = requests.get(self.snapshot_url, timeout=15, headers=headers,
-                                      stream=True, verify=False)
-
-            if response.status_code == 200:
-                # Check content size
-                content_length = int(response.headers.get('content-length', 0))
-                if content_length > self.max_file_size:
-                    logger.warning(f"Snapshot too large for camera {self.camera_id}: {content_length} bytes")
-                    return None
-
-                # Read content
-                content = response.content
-
-                # Convert to numpy array
-                image_array = np.frombuffer(content, np.uint8)
-
-                # Decode as high quality image
-                frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
-
-                if frame is None:
-                    logger.error(f"Failed to decode snapshot for camera {self.camera_id}")
-                    return None
-
-                logger.debug(f"Fetched snapshot for camera {self.camera_id}: {frame.shape[1]}x{frame.shape[0]}")
-                return frame
-            else:
-                logger.warning(f"HTTP {response.status_code} from {self.camera_id}")
-                return None
-
-        except requests.RequestException as e:
-            logger.error(f"Request error fetching snapshot for {self.camera_id}: {e}")
-            return None
-        except Exception as e:
-            logger.error(f"Error decoding snapshot for {self.camera_id}: {e}")
-            return None
-
-    def fetch_single_snapshot(self) -> Optional[np.ndarray]:
-        """
-        Fetch a single high-quality snapshot on demand for pipeline processing.
-        This method is for one-time fetch from HTTP URL, not continuous streaming.
-
-        Returns:
-            High quality 2K snapshot frame or None if failed
-        """
-        logger.info(f"[SNAPSHOT] Fetching snapshot for {self.camera_id} from {self.snapshot_url}")
-
-        # Try to fetch snapshot with retries
-        for attempt in range(self.max_retries):
-            frame = self._fetch_snapshot()
-
-            if frame is not None:
-                logger.info(f"[SNAPSHOT] Successfully fetched {frame.shape[1]}x{frame.shape[0]} snapshot for {self.camera_id}")
-                return frame
-
-            if attempt < self.max_retries - 1:
-                logger.warning(f"[SNAPSHOT] Attempt {attempt + 1}/{self.max_retries} failed for {self.camera_id}, retrying...")
-                time.sleep(0.5)
-
-        logger.error(f"[SNAPSHOT] Failed to fetch snapshot for {self.camera_id} after {self.max_retries} attempts")
-        return None
-
-    def _resize_maintain_aspect(self, frame: np.ndarray, target_width: int, target_height: int) -> np.ndarray:
-        """Resize image while maintaining aspect ratio for high quality."""
-        h, w = frame.shape[:2]
-        aspect = w / h
-        target_aspect = target_width / target_height
-
-        if aspect > target_aspect:
-            # Image is wider
-            new_width = target_width
-            new_height = int(target_width / aspect)
-        else:
-            # Image is taller
-            new_height = target_height
-            new_width = int(target_height * aspect)
-
-        # Use INTER_LANCZOS4 for high quality downsampling
-        resized = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_LANCZOS4)
-
-        # Pad to target size if needed
-        if new_width < target_width or new_height < target_height:
-            top = (target_height - new_height) // 2
-            bottom = target_height - new_height - top
-            left = (target_width - new_width) // 2
-            right = target_width - new_width - left
-            resized = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=[0, 0, 0])
-
-        return resized
\ No newline at end of file
diff --git a/core/streaming/readers/__init__.py b/core/streaming/readers/__init__.py
new file mode 100644
index 0000000..0903d6d
--- /dev/null
+++ b/core/streaming/readers/__init__.py
@@ -0,0 +1,18 @@
+"""
+Stream readers for RTSP and HTTP camera feeds.
+"""
+from .base import VideoReader
+from .ffmpeg_rtsp import FFmpegRTSPReader
+from .http_snapshot import HTTPSnapshotReader
+from .utils import log_success, log_warning, log_error, log_info, Colors
+
+__all__ = [
+    'VideoReader',
+    'FFmpegRTSPReader',
+    'HTTPSnapshotReader',
+    'log_success',
+    'log_warning',
+    'log_error',
+    'log_info',
+    'Colors'
+]
\ No newline at end of file
diff --git a/core/streaming/readers/base.py b/core/streaming/readers/base.py
new file mode 100644
index 0000000..56c41cb
--- /dev/null
+++ b/core/streaming/readers/base.py
@@ -0,0 +1,65 @@
+"""
+Abstract base class for video stream readers.
+"""
+from abc import ABC, abstractmethod
+from typing import Optional, Callable
+import numpy as np
+
+
+class VideoReader(ABC):
+    """Abstract base class for video stream readers."""
+
+    def __init__(self, camera_id: str, source_url: str, max_retries: int = 3):
+        """
+        Initialize the video reader.
+
+        Args:
+            camera_id: Unique identifier for the camera
+            source_url: URL or path to the video source
+            max_retries: Maximum number of retry attempts
+        """
+        self.camera_id = camera_id
+        self.source_url = source_url
+        self.max_retries = max_retries
+        self.frame_callback: Optional[Callable[[str, np.ndarray], None]] = None
+
+    @abstractmethod
+    def start(self) -> None:
+        """Start the video reader."""
+        pass
+
+    @abstractmethod
+    def stop(self) -> None:
+        """Stop the video reader."""
+        pass
+
+    @abstractmethod
+    def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]) -> None:
+        """
+        Set callback function to handle captured frames.
+
+        Args:
+            callback: Function that takes (camera_id, frame) as arguments
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def is_running(self) -> bool:
+        """Check if the reader is currently running."""
+        pass
+
+    @property
+    @abstractmethod
+    def reader_type(self) -> str:
+        """Get the type of reader (e.g., 'rtsp', 'http_snapshot')."""
+        pass
+
+    def __enter__(self):
+        """Context manager entry."""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit."""
+        self.stop()
\ No newline at end of file
diff --git a/core/streaming/readers/ffmpeg_rtsp.py b/core/streaming/readers/ffmpeg_rtsp.py
new file mode 100644
index 0000000..88f45ae
--- /dev/null
+++ b/core/streaming/readers/ffmpeg_rtsp.py
@@ -0,0 +1,436 @@
+"""
+FFmpeg RTSP stream reader using subprocess piping frames directly to buffer.
+Enhanced with comprehensive health monitoring and automatic recovery.
+"""
+import cv2
+import time
+import threading
+import numpy as np
+import subprocess
+import struct
+from typing import Optional, Callable, Dict, Any
+
+from .base import VideoReader
+from .utils import log_success, log_warning, log_error, log_info
+from ...monitoring.stream_health import stream_health_tracker
+from ...monitoring.thread_health import thread_health_monitor
+from ...monitoring.recovery import recovery_manager, RecoveryAction
+
+
+class FFmpegRTSPReader(VideoReader):
+    """RTSP stream reader using subprocess FFmpeg piping frames directly to buffer."""
+
+    def __init__(self, camera_id: str, rtsp_url: str, max_retries: int = 3):
+        super().__init__(camera_id, rtsp_url, max_retries)
+        self.rtsp_url = rtsp_url
+        self.process = None
+        self.stop_event = threading.Event()
+        self.thread = None
+        self.stderr_thread = None
+
+        # Expected stream specs (for reference, actual dimensions read from PPM header)
+        self.width = 1280
+        self.height = 720
+
+        # Watchdog timers for stream reliability
+        self.process_start_time = None
+        self.last_frame_time = None
+        self.is_restart = False  # Track if this is a restart (shorter timeout)
+        self.first_start_timeout = 30.0  # 30s timeout on first start
+        self.restart_timeout = 15.0      # 15s timeout after restart
+
+        # Health monitoring setup
+        self.last_heartbeat = time.time()
+        self.consecutive_errors = 0
+        self.ffmpeg_restart_count = 0
+
+        # Register recovery handlers
+        recovery_manager.register_recovery_handler(
+            RecoveryAction.RESTART_STREAM,
+            self._handle_restart_recovery
+        )
+        recovery_manager.register_recovery_handler(
+            RecoveryAction.RECONNECT,
+            self._handle_reconnect_recovery
+        )
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the reader is currently running."""
+        return self.thread is not None and self.thread.is_alive()
+
+    @property
+    def reader_type(self) -> str:
+        """Get the type of reader."""
+        return "rtsp_ffmpeg"
+
+    def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
+        """Set callback function to handle captured frames."""
+        self.frame_callback = callback
+
+    def start(self):
+        """Start the FFmpeg subprocess reader."""
+        if self.thread and self.thread.is_alive():
+            log_warning(self.camera_id, "FFmpeg reader already running")
+            return
+
+        self.stop_event.clear()
+        self.thread = threading.Thread(target=self._read_frames, daemon=True)
+        self.thread.start()
+
+        # Register with health monitoring
+        stream_health_tracker.register_stream(self.camera_id, "rtsp_ffmpeg", self.rtsp_url)
+        thread_health_monitor.register_thread(self.thread, self._heartbeat_callback)
+
+        log_success(self.camera_id, "Stream started with health monitoring")
+
+    def stop(self):
+        """Stop the FFmpeg subprocess reader."""
+        self.stop_event.set()
+
+        # Unregister from health monitoring
+        if self.thread:
+            thread_health_monitor.unregister_thread(self.thread.ident)
+
+        if self.process:
+            self.process.terminate()
+            try:
+                self.process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+
+        if self.thread:
+            self.thread.join(timeout=5.0)
+        if self.stderr_thread:
+            self.stderr_thread.join(timeout=2.0)
+
+        stream_health_tracker.unregister_stream(self.camera_id)
+
+        log_info(self.camera_id, "Stream stopped")
+
+    def _start_ffmpeg_process(self):
+        """Start FFmpeg subprocess outputting BMP frames to stdout pipe."""
+        cmd = [
+            'ffmpeg',
+            # DO NOT REMOVE
+            '-hwaccel', 'cuda',
+            '-hwaccel_device', '0',
+            # Real-time input flags
+            '-fflags', 'nobuffer+genpts',
+            '-flags', 'low_delay',
+            '-max_delay', '0',             # No reordering delay
+            # RTSP configuration
+            '-rtsp_transport', 'tcp',
+            '-i', self.rtsp_url,
+            # Output configuration (keeping BMP)
+            '-f', 'image2pipe',  # Output images to pipe
+            '-vcodec', 'bmp',    # BMP format with header containing dimensions
+            '-vsync', 'passthrough',       # Pass frames as-is
+            # Use native stream resolution and framerate
+            '-an',               # No audio
+            '-'                  # Output to stdout
+        ]
+
+        try:
+            # Start FFmpeg with stdout pipe to read frames directly
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,  # Capture stdout for frame data
+                stderr=subprocess.PIPE,  # Capture stderr for error logging
+                bufsize=0  # Unbuffered for real-time processing
+            )
+
+            # Start stderr reading thread
+            if self.stderr_thread and self.stderr_thread.is_alive():
+                # Stop previous stderr thread
+                try:
+                    self.stderr_thread.join(timeout=1.0)
+                except:
+                    pass
+
+            self.stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
+            self.stderr_thread.start()
+
+            # Set process start time for watchdog
+            self.process_start_time = time.time()
+            self.last_frame_time = None  # Reset frame time
+
+            # After successful restart, next timeout will be back to 30s
+            if self.is_restart:
+                log_info(self.camera_id, f"FFmpeg restarted successfully, next timeout: {self.first_start_timeout}s")
+                self.is_restart = False
+
+            return True
+        except Exception as e:
+            log_error(self.camera_id, f"FFmpeg startup failed: {e}")
+            return False
+
+    def _read_bmp_frame(self, pipe):
+        """Read BMP frame from pipe - BMP header contains dimensions."""
+        try:
+            # Read BMP header (14 bytes file header + 40 bytes info header = 54 bytes minimum)
+            header_data = b''
+            bytes_to_read = 54
+
+            while len(header_data) < bytes_to_read:
+                chunk = pipe.read(bytes_to_read - len(header_data))
+                if not chunk:
+                    return None  # Silent end of stream
+                header_data += chunk
+
+            # Parse BMP header
+            if header_data[:2] != b'BM':
+                return None  # Invalid format, skip frame silently
+
+            # Extract file size from header (bytes 2-5)
+            file_size = struct.unpack('<L', header_data[2:6])[0]
+
+            # Extract width and height from info header (bytes 18-21 and 22-25)
+            width = struct.unpack('<L', header_data[18:22])[0]
+            height = struct.unpack('<L', header_data[22:26])[0]
+
+            # Read remaining file data
+            remaining_size = file_size - 54
+            remaining_data = b''
+
+            while len(remaining_data) < remaining_size:
+                chunk = pipe.read(remaining_size - len(remaining_data))
+                if not chunk:
+                    return None  # Stream ended silently
+                remaining_data += chunk
+
+            # Complete BMP data
+            bmp_data = header_data + remaining_data
+
+            # Use OpenCV to decode BMP directly from memory
+            frame_array = np.frombuffer(bmp_data, dtype=np.uint8)
+            frame = cv2.imdecode(frame_array, cv2.IMREAD_COLOR)
+
+            if frame is None:
+                return None  # Decode failed silently
+
+            return frame
+
+        except Exception:
+            return None  # Error reading frame silently
+
+    def _read_stderr(self):
+        """Read and log FFmpeg stderr output in background thread."""
+        if not self.process or not self.process.stderr:
+            return
+
+        try:
+            while self.process and self.process.poll() is None:
+                try:
+                    line = self.process.stderr.readline()
+                    if line:
+                        error_msg = line.decode('utf-8', errors='ignore').strip()
+                        if error_msg and not self.stop_event.is_set():
+                            # Filter out common noise but log actual errors
+                            if any(keyword in error_msg.lower() for keyword in ['error', 'failed', 'cannot', 'invalid']):
+                                log_error(self.camera_id, f"FFmpeg: {error_msg}")
+                            elif 'warning' in error_msg.lower():
+                                log_warning(self.camera_id, f"FFmpeg: {error_msg}")
+                except Exception:
+                    break
+        except Exception:
+            pass
+
+    def _check_watchdog_timeout(self) -> bool:
+        """Check if watchdog timeout has been exceeded."""
+        if not self.process_start_time:
+            return False
+
+        current_time = time.time()
+        time_since_start = current_time - self.process_start_time
+
+        # Determine timeout based on whether this is a restart
+        timeout = self.restart_timeout if self.is_restart else self.first_start_timeout
+
+        # If no frames received yet, check against process start time
+        if not self.last_frame_time:
+            if time_since_start > timeout:
+                log_warning(self.camera_id, f"Watchdog timeout: No frames for {time_since_start:.1f}s (limit: {timeout}s)")
+                return True
+        else:
+            # Check time since last frame
+            time_since_frame = current_time - self.last_frame_time
+            if time_since_frame > timeout:
+                log_warning(self.camera_id, f"Watchdog timeout: No frames for {time_since_frame:.1f}s (limit: {timeout}s)")
+                return True
+
+        return False
+
+    def _restart_ffmpeg_process(self):
+        """Restart FFmpeg process due to watchdog timeout."""
+        log_warning(self.camera_id, "Watchdog triggered FFmpeg restart")
+
+        # Terminate current process
+        if self.process:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                self.process.kill()
+            except Exception:
+                pass
+            self.process = None
+
+        # Mark as restart for shorter timeout
+        self.is_restart = True
+
+        # Small delay before restart
+        time.sleep(1.0)
+
+    def _read_frames(self):
+        """Read frames directly from FFmpeg stdout pipe."""
+        frame_count = 0
+        last_log_time = time.time()
+
+        while not self.stop_event.is_set():
+            try:
+                # Send heartbeat for thread health monitoring
+                self._send_heartbeat("reading_frames")
+
+                # Check watchdog timeout if process is running
+                if self.process and self.process.poll() is None:
+                    if self._check_watchdog_timeout():
+                        self._restart_ffmpeg_process()
+                        continue
+
+                # Start FFmpeg if not running
+                if not self.process or self.process.poll() is not None:
+                    if self.process and self.process.poll() is not None:
+                        log_warning(self.camera_id, "Stream disconnected, reconnecting...")
+                        stream_health_tracker.report_error(
+                            self.camera_id,
+                            "FFmpeg process disconnected"
+                        )
+
+                    if not self._start_ffmpeg_process():
+                        self.consecutive_errors += 1
+                        stream_health_tracker.report_error(
+                            self.camera_id,
+                            "Failed to start FFmpeg process"
+                        )
+                        time.sleep(5.0)
+                        continue
+
+                # Read frames directly from FFmpeg stdout
+                try:
+                    if self.process and self.process.stdout:
+                        # Read BMP frame data
+                        frame = self._read_bmp_frame(self.process.stdout)
+                        if frame is None:
+                            continue
+
+                        # Update watchdog - we got a frame
+                        self.last_frame_time = time.time()
+
+                        # Reset error counter on successful frame
+                        self.consecutive_errors = 0
+
+                        # Report successful frame to health monitoring
+                        frame_size = frame.nbytes
+                        stream_health_tracker.report_frame_received(self.camera_id, frame_size)
+
+                        # Call frame callback
+                        if self.frame_callback:
+                            try:
+                                self.frame_callback(self.camera_id, frame)
+                            except Exception as e:
+                                stream_health_tracker.report_error(
+                                    self.camera_id,
+                                    f"Frame callback error: {e}"
+                                )
+
+                        frame_count += 1
+
+                        # Log progress every 60 seconds (quieter)
+                        current_time = time.time()
+                        if current_time - last_log_time >= 60:
+                            log_success(self.camera_id, f"{frame_count} frames captured ({frame.shape[1]}x{frame.shape[0]})")
+                            last_log_time = current_time
+
+                except Exception as e:
+                    # Process might have died, let it restart on next iteration
+                    stream_health_tracker.report_error(
+                        self.camera_id,
+                        f"Frame reading error: {e}"
+                    )
+                    if self.process:
+                        self.process.terminate()
+                        self.process = None
+                    time.sleep(1.0)
+
+            except Exception as e:
+                stream_health_tracker.report_error(
+                    self.camera_id,
+                    f"Main loop error: {e}"
+                )
+                time.sleep(1.0)
+
+        # Cleanup
+        if self.process:
+            self.process.terminate()
+
+    # Health monitoring methods
+    def _send_heartbeat(self, activity: str = "running"):
+        """Send heartbeat to thread health monitor."""
+        self.last_heartbeat = time.time()
+        thread_health_monitor.heartbeat(activity=activity)
+
+    def _heartbeat_callback(self) -> bool:
+        """Heartbeat callback for thread responsiveness testing."""
+        try:
+            # Check if thread is responsive by checking recent heartbeat
+            current_time = time.time()
+            age = current_time - self.last_heartbeat
+
+            # Thread is responsive if heartbeat is recent
+            return age < 30.0  # 30 second responsiveness threshold
+
+        except Exception:
+            return False
+
+    def _handle_restart_recovery(self, component: str, details: Dict[str, Any]) -> bool:
+        """Handle restart recovery action."""
+        try:
+            log_info(self.camera_id, "Restarting FFmpeg RTSP reader for health recovery")
+
+            # Stop current instance
+            self.stop()
+
+            # Small delay
+            time.sleep(2.0)
+
+            # Restart
+            self.start()
+
+            # Report successful restart
+            stream_health_tracker.report_reconnect(self.camera_id, "health_recovery_restart")
+            self.ffmpeg_restart_count += 1
+
+            return True
+
+        except Exception as e:
+            log_error(self.camera_id, f"Failed to restart FFmpeg RTSP reader: {e}")
+            return False
+
+    def _handle_reconnect_recovery(self, component: str, details: Dict[str, Any]) -> bool:
+        """Handle reconnect recovery action."""
+        try:
+            log_info(self.camera_id, "Reconnecting FFmpeg RTSP reader for health recovery")
+
+            # Force restart FFmpeg process
+            self._restart_ffmpeg_process()
+
+            # Reset error counters
+            self.consecutive_errors = 0
+            stream_health_tracker.report_reconnect(self.camera_id, "health_recovery_reconnect")
+
+            return True
+
+        except Exception as e:
+            log_error(self.camera_id, f"Failed to reconnect FFmpeg RTSP reader: {e}")
+            return False
\ No newline at end of file
diff --git a/core/streaming/readers/http_snapshot.py b/core/streaming/readers/http_snapshot.py
new file mode 100644
index 0000000..bbbf943
--- /dev/null
+++ b/core/streaming/readers/http_snapshot.py
@@ -0,0 +1,378 @@
+"""
+HTTP snapshot reader optimized for 2560x1440 (2K) high quality images.
+Enhanced with comprehensive health monitoring and automatic recovery.
+"""
+import cv2
+import logging
+import time
+import threading
+import requests
+import numpy as np
+from typing import Optional, Callable, Dict, Any
+
+from .base import VideoReader
+from .utils import log_success, log_warning, log_error, log_info
+from ...monitoring.stream_health import stream_health_tracker
+from ...monitoring.thread_health import thread_health_monitor
+from ...monitoring.recovery import recovery_manager, RecoveryAction
+
+logger = logging.getLogger(__name__)
+
+
+class HTTPSnapshotReader(VideoReader):
+    """HTTP snapshot reader optimized for 2560x1440 (2K) high quality images."""
+
+    def __init__(self, camera_id: str, snapshot_url: str, interval_ms: int = 5000, max_retries: int = 3):
+        super().__init__(camera_id, snapshot_url, max_retries)
+        self.snapshot_url = snapshot_url
+        self.interval_ms = interval_ms
+        self.stop_event = threading.Event()
+        self.thread = None
+
+        # Expected snapshot specifications
+        self.expected_width = 2560
+        self.expected_height = 1440
+        self.max_file_size = 10 * 1024 * 1024  # 10MB max for 2K image
+
+        # Health monitoring setup
+        self.last_heartbeat = time.time()
+        self.consecutive_errors = 0
+        self.connection_test_interval = 300  # Test connection every 5 minutes
+        self.last_connection_test = None
+
+        # Register recovery handlers
+        recovery_manager.register_recovery_handler(
+            RecoveryAction.RESTART_STREAM,
+            self._handle_restart_recovery
+        )
+        recovery_manager.register_recovery_handler(
+            RecoveryAction.RECONNECT,
+            self._handle_reconnect_recovery
+        )
+
+    @property
+    def is_running(self) -> bool:
+        """Check if the reader is currently running."""
+        return self.thread is not None and self.thread.is_alive()
+
+    @property
+    def reader_type(self) -> str:
+        """Get the type of reader."""
+        return "http_snapshot"
+
+    def set_frame_callback(self, callback: Callable[[str, np.ndarray], None]):
+        """Set callback function to handle captured frames."""
+        self.frame_callback = callback
+
+    def start(self):
+        """Start the snapshot reader thread."""
+        if self.thread and self.thread.is_alive():
+            logger.warning(f"Snapshot reader for {self.camera_id} already running")
+            return
+
+        self.stop_event.clear()
+        self.thread = threading.Thread(target=self._read_snapshots, daemon=True)
+        self.thread.start()
+
+        # Register with health monitoring
+        stream_health_tracker.register_stream(self.camera_id, "http_snapshot", self.snapshot_url)
+        thread_health_monitor.register_thread(self.thread, self._heartbeat_callback)
+
+        logger.info(f"Started snapshot reader for camera {self.camera_id} with health monitoring")
+
+    def stop(self):
+        """Stop the snapshot reader thread."""
+        self.stop_event.set()
+
+        # Unregister from health monitoring
+        if self.thread:
+            thread_health_monitor.unregister_thread(self.thread.ident)
+            self.thread.join(timeout=5.0)
+
+        stream_health_tracker.unregister_stream(self.camera_id)
+
+        logger.info(f"Stopped snapshot reader for camera {self.camera_id}")
+
+    def _read_snapshots(self):
+        """Main snapshot reading loop for high quality 2K images."""
+        retries = 0
+        frame_count = 0
+        last_log_time = time.time()
+        last_connection_test = time.time()
+        interval_seconds = self.interval_ms / 1000.0
+
+        logger.info(f"Snapshot interval for camera {self.camera_id}: {interval_seconds}s")
+
+        while not self.stop_event.is_set():
+            try:
+                # Send heartbeat for thread health monitoring
+                self._send_heartbeat("fetching_snapshot")
+
+                start_time = time.time()
+                frame = self._fetch_snapshot()
+
+                if frame is None:
+                    retries += 1
+                    self.consecutive_errors += 1
+
+                    # Report error to health monitoring
+                    stream_health_tracker.report_error(
+                        self.camera_id,
+                        f"Failed to fetch snapshot (retry {retries}/{self.max_retries})"
+                    )
+
+                    logger.warning(f"Failed to fetch snapshot for camera {self.camera_id}, retry {retries}/{self.max_retries}")
+
+                    if self.max_retries != -1 and retries > self.max_retries:
+                        logger.error(f"Max retries reached for snapshot camera {self.camera_id}")
+                        break
+
+                    time.sleep(min(2.0, interval_seconds))
+                    continue
+
+                # Accept any valid image dimensions - don't force specific resolution
+                if frame.shape[1] <= 0 or frame.shape[0] <= 0:
+                    logger.warning(f"Camera {self.camera_id}: Invalid frame dimensions {frame.shape[1]}x{frame.shape[0]}")
+                    stream_health_tracker.report_error(
+                        self.camera_id,
+                        f"Invalid frame dimensions: {frame.shape[1]}x{frame.shape[0]}"
+                    )
+                    continue
+
+                # Reset retry counter on successful fetch
+                retries = 0
+                self.consecutive_errors = 0
+                frame_count += 1
+
+                # Report successful frame to health monitoring
+                frame_size = frame.nbytes
+                stream_health_tracker.report_frame_received(self.camera_id, frame_size)
+
+                # Call frame callback
+                if self.frame_callback:
+                    try:
+                        self.frame_callback(self.camera_id, frame)
+                    except Exception as e:
+                        logger.error(f"Camera {self.camera_id}: Frame callback error: {e}")
+                        stream_health_tracker.report_error(self.camera_id, f"Frame callback error: {e}")
+
+                # Periodic connection health test
+                current_time = time.time()
+                if current_time - last_connection_test >= self.connection_test_interval:
+                    self._test_connection_health()
+                    last_connection_test = current_time
+
+                # Log progress every 30 seconds
+                if current_time - last_log_time >= 30:
+                    logger.info(f"Camera {self.camera_id}: {frame_count} snapshots processed")
+                    last_log_time = current_time
+
+                # Wait for next interval
+                elapsed = time.time() - start_time
+                sleep_time = max(0, interval_seconds - elapsed)
+                if sleep_time > 0:
+                    self.stop_event.wait(sleep_time)
+
+            except Exception as e:
+                logger.error(f"Error in snapshot loop for camera {self.camera_id}: {e}")
+                stream_health_tracker.report_error(self.camera_id, f"Snapshot loop error: {e}")
+                retries += 1
+                if self.max_retries != -1 and retries > self.max_retries:
+                    break
+                time.sleep(min(2.0, interval_seconds))
+
+        logger.info(f"Snapshot reader thread ended for camera {self.camera_id}")
+
+    def _fetch_snapshot(self) -> Optional[np.ndarray]:
+        """Fetch a single high quality snapshot from HTTP URL."""
+        try:
+            # Parse URL for authentication
+            from urllib.parse import urlparse
+            parsed_url = urlparse(self.snapshot_url)
+
+            headers = {
+                'User-Agent': 'Python-Detector-Worker/1.0',
+                'Accept': 'image/jpeg, image/png, image/*'
+            }
+            auth = None
+
+            if parsed_url.username and parsed_url.password:
+                from requests.auth import HTTPBasicAuth, HTTPDigestAuth
+                auth = HTTPBasicAuth(parsed_url.username, parsed_url.password)
+
+                # Reconstruct URL without credentials
+                clean_url = f"{parsed_url.scheme}://{parsed_url.hostname}"
+                if parsed_url.port:
+                    clean_url += f":{parsed_url.port}"
+                clean_url += parsed_url.path
+                if parsed_url.query:
+                    clean_url += f"?{parsed_url.query}"
+
+                # Try Basic Auth first
+                response = requests.get(clean_url, auth=auth, timeout=15, headers=headers,
+                                       stream=True, verify=False)
+
+                # If Basic Auth fails, try Digest Auth
+                if response.status_code == 401:
+                    auth = HTTPDigestAuth(parsed_url.username, parsed_url.password)
+                    response = requests.get(clean_url, auth=auth, timeout=15, headers=headers,
+                                          stream=True, verify=False)
+            else:
+                response = requests.get(self.snapshot_url, timeout=15, headers=headers,
+                                      stream=True, verify=False)
+
+            if response.status_code == 200:
+                # Check content size
+                content_length = int(response.headers.get('content-length', 0))
+                if content_length > self.max_file_size:
+                    logger.warning(f"Snapshot too large for camera {self.camera_id}: {content_length} bytes")
+                    return None
+
+                # Read content
+                content = response.content
+
+                # Convert to numpy array
+                image_array = np.frombuffer(content, np.uint8)
+
+                # Decode as high quality image
+                frame = cv2.imdecode(image_array, cv2.IMREAD_COLOR)
+
+                if frame is None:
+                    logger.error(f"Failed to decode snapshot for camera {self.camera_id}")
+                    return None
+
+                logger.debug(f"Fetched snapshot for camera {self.camera_id}: {frame.shape[1]}x{frame.shape[0]}")
+                return frame
+            else:
+                logger.warning(f"HTTP {response.status_code} from {self.camera_id}")
+                return None
+
+        except requests.RequestException as e:
+            logger.error(f"Request error fetching snapshot for {self.camera_id}: {e}")
+            return None
+        except Exception as e:
+            logger.error(f"Error decoding snapshot for {self.camera_id}: {e}")
+            return None
+
+    def fetch_single_snapshot(self) -> Optional[np.ndarray]:
+        """
+        Fetch a single high-quality snapshot on demand for pipeline processing.
+        This method is for one-time fetch from HTTP URL, not continuous streaming.
+
+        Returns:
+            High quality 2K snapshot frame or None if failed
+        """
+        logger.info(f"[SNAPSHOT] Fetching snapshot for {self.camera_id} from {self.snapshot_url}")
+
+        # Try to fetch snapshot with retries
+        for attempt in range(self.max_retries):
+            frame = self._fetch_snapshot()
+
+            if frame is not None:
+                logger.info(f"[SNAPSHOT] Successfully fetched {frame.shape[1]}x{frame.shape[0]} snapshot for {self.camera_id}")
+                return frame
+
+            if attempt < self.max_retries - 1:
+                logger.warning(f"[SNAPSHOT] Attempt {attempt + 1}/{self.max_retries} failed for {self.camera_id}, retrying...")
+                time.sleep(0.5)
+
+        logger.error(f"[SNAPSHOT] Failed to fetch snapshot for {self.camera_id} after {self.max_retries} attempts")
+        return None
+
+    def _resize_maintain_aspect(self, frame: np.ndarray, target_width: int, target_height: int) -> np.ndarray:
+        """Resize image while maintaining aspect ratio for high quality."""
+        h, w = frame.shape[:2]
+        aspect = w / h
+        target_aspect = target_width / target_height
+
+        if aspect > target_aspect:
+            # Image is wider
+            new_width = target_width
+            new_height = int(target_width / aspect)
+        else:
+            # Image is taller
+            new_height = target_height
+            new_width = int(target_height * aspect)
+
+        # Use INTER_LANCZOS4 for high quality downsampling
+        resized = cv2.resize(frame, (new_width, new_height), interpolation=cv2.INTER_LANCZOS4)
+
+        # Pad to target size if needed
+        if new_width < target_width or new_height < target_height:
+            top = (target_height - new_height) // 2
+            bottom = target_height - new_height - top
+            left = (target_width - new_width) // 2
+            right = target_width - new_width - left
+            resized = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=[0, 0, 0])
+
+        return resized
+
+    # Health monitoring methods
+    def _send_heartbeat(self, activity: str = "running"):
+        """Send heartbeat to thread health monitor."""
+        self.last_heartbeat = time.time()
+        thread_health_monitor.heartbeat(activity=activity)
+
+    def _heartbeat_callback(self) -> bool:
+        """Heartbeat callback for thread responsiveness testing."""
+        try:
+            # Check if thread is responsive by checking recent heartbeat
+            current_time = time.time()
+            age = current_time - self.last_heartbeat
+
+            # Thread is responsive if heartbeat is recent
+            return age < 30.0  # 30 second responsiveness threshold
+
+        except Exception:
+            return False
+
+    def _test_connection_health(self):
+        """Test HTTP connection health."""
+        try:
+            stream_health_tracker.test_http_connection(self.camera_id, self.snapshot_url)
+        except Exception as e:
+            logger.error(f"Error testing connection health for {self.camera_id}: {e}")
+
+    def _handle_restart_recovery(self, component: str, details: Dict[str, Any]) -> bool:
+        """Handle restart recovery action."""
+        try:
+            logger.info(f"Restarting HTTP snapshot reader for {self.camera_id}")
+
+            # Stop current instance
+            self.stop()
+
+            # Small delay
+            time.sleep(2.0)
+
+            # Restart
+            self.start()
+
+            # Report successful restart
+            stream_health_tracker.report_reconnect(self.camera_id, "health_recovery_restart")
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to restart HTTP snapshot reader for {self.camera_id}: {e}")
+            return False
+
+    def _handle_reconnect_recovery(self, component: str, details: Dict[str, Any]) -> bool:
+        """Handle reconnect recovery action."""
+        try:
+            logger.info(f"Reconnecting HTTP snapshot reader for {self.camera_id}")
+
+            # Test connection first
+            success = stream_health_tracker.test_http_connection(self.camera_id, self.snapshot_url)
+
+            if success:
+                # Reset error counters
+                self.consecutive_errors = 0
+                stream_health_tracker.report_reconnect(self.camera_id, "health_recovery_reconnect")
+                return True
+            else:
+                logger.warning(f"Connection test failed during recovery for {self.camera_id}")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to reconnect HTTP snapshot reader for {self.camera_id}: {e}")
+            return False
\ No newline at end of file
diff --git a/core/streaming/readers/utils.py b/core/streaming/readers/utils.py
new file mode 100644
index 0000000..813f49f
--- /dev/null
+++ b/core/streaming/readers/utils.py
@@ -0,0 +1,38 @@
+"""
+Utility functions for stream readers.
+"""
+import logging
+import os
+
+# Keep OpenCV errors visible but allow FFmpeg stderr logging
+os.environ["OPENCV_LOG_LEVEL"] = "ERROR"
+
+logger = logging.getLogger(__name__)
+
+# Color codes for pretty logging
+class Colors:
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    BLUE = '\033[94m'
+    PURPLE = '\033[95m'
+    CYAN = '\033[96m'
+    WHITE = '\033[97m'
+    BOLD = '\033[1m'
+    END = '\033[0m'
+
+def log_success(camera_id: str, message: str):
+    """Log success messages in green"""
+    logger.info(f"{Colors.GREEN}[{camera_id}] {message}{Colors.END}")
+
+def log_warning(camera_id: str, message: str):
+    """Log warnings in yellow"""
+    logger.warning(f"{Colors.YELLOW}[{camera_id}] {message}{Colors.END}")
+
+def log_error(camera_id: str, message: str):
+    """Log errors in red"""
+    logger.error(f"{Colors.RED}[{camera_id}] {message}{Colors.END}")
+
+def log_info(camera_id: str, message: str):
+    """Log info in cyan"""
+    logger.info(f"{Colors.CYAN}[{camera_id}] {message}{Colors.END}")
\ No newline at end of file
diff --git a/core/tracking/bot_sort_tracker.py b/core/tracking/bot_sort_tracker.py
new file mode 100644
index 0000000..f487a6a
--- /dev/null
+++ b/core/tracking/bot_sort_tracker.py
@@ -0,0 +1,408 @@
+"""
+BoT-SORT Multi-Object Tracker with Camera Isolation
+Based on BoT-SORT: Robust Associations Multi-Pedestrian Tracking
+"""
+
+import logging
+import time
+import numpy as np
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+from scipy.optimize import linear_sum_assignment
+from filterpy.kalman import KalmanFilter
+import cv2
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class TrackState:
+    """Track state enumeration"""
+    TENTATIVE = "tentative"      # New track, not confirmed yet
+    CONFIRMED = "confirmed"      # Confirmed track
+    DELETED = "deleted"          # Track to be deleted
+
+
+class Track:
+    """
+    Individual track representation with Kalman filter for motion prediction
+    """
+
+    def __init__(self, detection, track_id: int, camera_id: str):
+        """
+        Initialize a new track
+
+        Args:
+            detection: Initial detection (bbox, confidence, class)
+            track_id: Unique track identifier within camera
+            camera_id: Camera identifier
+        """
+        self.track_id = track_id
+        self.camera_id = camera_id
+        self.state = TrackState.TENTATIVE
+
+        # Time tracking
+        self.start_time = time.time()
+        self.last_update_time = time.time()
+
+        # Appearance and motion
+        self.bbox = detection.bbox  # [x1, y1, x2, y2]
+        self.confidence = detection.confidence
+        self.class_name = detection.class_name
+
+        # Track management
+        self.hit_streak = 1
+        self.time_since_update = 0
+        self.age = 1
+
+        # Kalman filter for motion prediction
+        self.kf = self._create_kalman_filter()
+        self._update_kalman_filter(detection.bbox)
+
+        # Track history
+        self.history = [detection.bbox]
+        self.max_history = 10
+
+    def _create_kalman_filter(self) -> KalmanFilter:
+        """Create Kalman filter for bbox tracking (x, y, w, h, vx, vy, vw, vh)"""
+        kf = KalmanFilter(dim_x=8, dim_z=4)
+
+        # State transition matrix (constant velocity model)
+        kf.F = np.array([
+            [1, 0, 0, 0, 1, 0, 0, 0],
+            [0, 1, 0, 0, 0, 1, 0, 0],
+            [0, 0, 1, 0, 0, 0, 1, 0],
+            [0, 0, 0, 1, 0, 0, 0, 1],
+            [0, 0, 0, 0, 1, 0, 0, 0],
+            [0, 0, 0, 0, 0, 1, 0, 0],
+            [0, 0, 0, 0, 0, 0, 1, 0],
+            [0, 0, 0, 0, 0, 0, 0, 1]
+        ])
+
+        # Measurement matrix (observe x, y, w, h)
+        kf.H = np.array([
+            [1, 0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 0, 0, 0, 0, 0, 0],
+            [0, 0, 1, 0, 0, 0, 0, 0],
+            [0, 0, 0, 1, 0, 0, 0, 0]
+        ])
+
+        # Process noise
+        kf.Q *= 0.01
+
+        # Measurement noise
+        kf.R *= 10
+
+        # Initial covariance
+        kf.P *= 100
+
+        return kf
+
+    def _update_kalman_filter(self, bbox: List[float]):
+        """Update Kalman filter with new bbox"""
+        # Convert [x1, y1, x2, y2] to [cx, cy, w, h]
+        x1, y1, x2, y2 = bbox
+        cx = (x1 + x2) / 2
+        cy = (y1 + y2) / 2
+        w = x2 - x1
+        h = y2 - y1
+
+        # Properly assign to column vector
+        self.kf.x[:4, 0] = [cx, cy, w, h]
+
+    def predict(self) -> np.ndarray:
+        """Predict next position using Kalman filter"""
+        self.kf.predict()
+
+        # Convert back to [x1, y1, x2, y2] format
+        cx, cy, w, h = self.kf.x[:4, 0]  # Extract from column vector
+        x1 = cx - w/2
+        y1 = cy - h/2
+        x2 = cx + w/2
+        y2 = cy + h/2
+
+        return np.array([x1, y1, x2, y2])
+
+    def update(self, detection):
+        """Update track with new detection"""
+        self.last_update_time = time.time()
+        self.time_since_update = 0
+        self.hit_streak += 1
+        self.age += 1
+
+        # Update track properties
+        self.bbox = detection.bbox
+        self.confidence = detection.confidence
+
+        # Update Kalman filter
+        x1, y1, x2, y2 = detection.bbox
+        cx = (x1 + x2) / 2
+        cy = (y1 + y2) / 2
+        w = x2 - x1
+        h = y2 - y1
+
+        self.kf.update([cx, cy, w, h])
+
+        # Update history
+        self.history.append(detection.bbox)
+        if len(self.history) > self.max_history:
+            self.history.pop(0)
+
+        # Update state
+        if self.state == TrackState.TENTATIVE and self.hit_streak >= 3:
+            self.state = TrackState.CONFIRMED
+
+    def mark_missed(self):
+        """Mark track as missed in this frame"""
+        self.time_since_update += 1
+        self.age += 1
+
+        if self.time_since_update > 5:  # Delete after 5 missed frames
+            self.state = TrackState.DELETED
+
+    def is_confirmed(self) -> bool:
+        """Check if track is confirmed"""
+        return self.state == TrackState.CONFIRMED
+
+    def is_deleted(self) -> bool:
+        """Check if track should be deleted"""
+        return self.state == TrackState.DELETED
+
+
+class CameraTracker:
+    """
+    BoT-SORT tracker for a single camera
+    """
+
+    def __init__(self, camera_id: str, max_disappeared: int = 10):
+        """
+        Initialize camera tracker
+
+        Args:
+            camera_id: Unique camera identifier
+            max_disappeared: Maximum frames a track can be missed before deletion
+        """
+        self.camera_id = camera_id
+        self.max_disappeared = max_disappeared
+
+        # Track management
+        self.tracks: Dict[int, Track] = {}
+        self.next_id = 1
+        self.frame_count = 0
+
+        logger.info(f"Initialized BoT-SORT tracker for camera {camera_id}")
+
+    def update(self, detections: List) -> List[Track]:
+        """
+        Update tracker with new detections
+
+        Args:
+            detections: List of Detection objects
+
+        Returns:
+            List of active confirmed tracks
+        """
+        self.frame_count += 1
+
+        # Predict all existing tracks
+        for track in self.tracks.values():
+            track.predict()
+
+        # Associate detections to tracks
+        matched_tracks, unmatched_detections, unmatched_tracks = self._associate(detections)
+
+        # Update matched tracks
+        for track_id, detection in matched_tracks:
+            self.tracks[track_id].update(detection)
+
+        # Mark unmatched tracks as missed
+        for track_id in unmatched_tracks:
+            self.tracks[track_id].mark_missed()
+
+        # Create new tracks for unmatched detections
+        for detection in unmatched_detections:
+            track = Track(detection, self.next_id, self.camera_id)
+            self.tracks[self.next_id] = track
+            self.next_id += 1
+
+        # Remove deleted tracks
+        tracks_to_remove = [tid for tid, track in self.tracks.items() if track.is_deleted()]
+        for tid in tracks_to_remove:
+            del self.tracks[tid]
+
+        # Return confirmed tracks
+        confirmed_tracks = [track for track in self.tracks.values() if track.is_confirmed()]
+
+        return confirmed_tracks
+
+    def _associate(self, detections: List) -> Tuple[List[Tuple[int, Any]], List[Any], List[int]]:
+        """
+        Associate detections to existing tracks using IoU distance
+
+        Returns:
+            (matched_tracks, unmatched_detections, unmatched_tracks)
+        """
+        if not detections or not self.tracks:
+            return [], detections, list(self.tracks.keys())
+
+        # Calculate IoU distance matrix
+        track_ids = list(self.tracks.keys())
+        cost_matrix = np.zeros((len(track_ids), len(detections)))
+
+        for i, track_id in enumerate(track_ids):
+            track = self.tracks[track_id]
+            predicted_bbox = track.predict()
+
+            for j, detection in enumerate(detections):
+                iou = self._calculate_iou(predicted_bbox, detection.bbox)
+                cost_matrix[i, j] = 1 - iou  # Convert IoU to distance
+
+        # Solve assignment problem
+        row_indices, col_indices = linear_sum_assignment(cost_matrix)
+
+        # Filter matches by IoU threshold
+        iou_threshold = 0.3
+        matched_tracks = []
+        matched_detection_indices = set()
+        matched_track_indices = set()
+
+        for row, col in zip(row_indices, col_indices):
+            if cost_matrix[row, col] <= (1 - iou_threshold):
+                track_id = track_ids[row]
+                detection = detections[col]
+                matched_tracks.append((track_id, detection))
+                matched_detection_indices.add(col)
+                matched_track_indices.add(row)
+
+        # Find unmatched detections and tracks
+        unmatched_detections = [detections[i] for i in range(len(detections))
+                             if i not in matched_detection_indices]
+        unmatched_tracks = [track_ids[i] for i in range(len(track_ids))
+                          if i not in matched_track_indices]
+
+        return matched_tracks, unmatched_detections, unmatched_tracks
+
+    def _calculate_iou(self, bbox1: np.ndarray, bbox2: List[float]) -> float:
+        """Calculate IoU between two bounding boxes"""
+        x1_1, y1_1, x2_1, y2_1 = bbox1
+        x1_2, y1_2, x2_2, y2_2 = bbox2
+
+        # Calculate intersection area
+        x1_i = max(x1_1, x1_2)
+        y1_i = max(y1_1, y1_2)
+        x2_i = min(x2_1, x2_2)
+        y2_i = min(y2_1, y2_2)
+
+        if x2_i <= x1_i or y2_i <= y1_i:
+            return 0.0
+
+        intersection = (x2_i - x1_i) * (y2_i - y1_i)
+
+        # Calculate union area
+        area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+        area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+        union = area1 + area2 - intersection
+
+        return intersection / union if union > 0 else 0.0
+
+
+class MultiCameraBoTSORT:
+    """
+    Multi-camera BoT-SORT tracker with complete camera isolation
+    """
+
+    def __init__(self, trigger_classes: List[str], min_confidence: float = 0.6):
+        """
+        Initialize multi-camera tracker
+
+        Args:
+            trigger_classes: List of class names to track
+            min_confidence: Minimum detection confidence threshold
+        """
+        self.trigger_classes = trigger_classes
+        self.min_confidence = min_confidence
+
+        # Camera-specific trackers
+        self.camera_trackers: Dict[str, CameraTracker] = {}
+
+        logger.info(f"Initialized MultiCameraBoTSORT with classes={trigger_classes}, "
+                   f"min_confidence={min_confidence}")
+
+    def get_or_create_tracker(self, camera_id: str) -> CameraTracker:
+        """Get or create tracker for specific camera"""
+        if camera_id not in self.camera_trackers:
+            self.camera_trackers[camera_id] = CameraTracker(camera_id)
+            logger.info(f"Created new tracker for camera {camera_id}")
+
+        return self.camera_trackers[camera_id]
+
+    def update(self, camera_id: str, inference_result) -> List[Dict]:
+        """
+        Update tracker for specific camera with detections
+
+        Args:
+            camera_id: Camera identifier
+            inference_result: InferenceResult with detections
+
+        Returns:
+            List of track information dictionaries
+        """
+        # Filter detections by confidence and trigger classes
+        filtered_detections = []
+
+        if hasattr(inference_result, 'detections') and inference_result.detections:
+            for detection in inference_result.detections:
+                if (detection.confidence >= self.min_confidence and
+                    detection.class_name in self.trigger_classes):
+                    filtered_detections.append(detection)
+
+        # Get camera tracker and update
+        tracker = self.get_or_create_tracker(camera_id)
+        confirmed_tracks = tracker.update(filtered_detections)
+
+        # Convert tracks to output format
+        track_results = []
+        for track in confirmed_tracks:
+            track_results.append({
+                'track_id': track.track_id,
+                'camera_id': track.camera_id,
+                'bbox': track.bbox,
+                'confidence': track.confidence,
+                'class_name': track.class_name,
+                'hit_streak': track.hit_streak,
+                'age': track.age
+            })
+
+        return track_results
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get tracking statistics across all cameras"""
+        stats = {}
+        total_tracks = 0
+
+        for camera_id, tracker in self.camera_trackers.items():
+            camera_stats = {
+                'active_tracks': len([t for t in tracker.tracks.values() if t.is_confirmed()]),
+                'total_tracks': len(tracker.tracks),
+                'frame_count': tracker.frame_count
+            }
+            stats[camera_id] = camera_stats
+            total_tracks += camera_stats['active_tracks']
+
+        stats['summary'] = {
+            'total_cameras': len(self.camera_trackers),
+            'total_active_tracks': total_tracks
+        }
+
+        return stats
+
+    def reset_camera(self, camera_id: str):
+        """Reset tracking for specific camera"""
+        if camera_id in self.camera_trackers:
+            del self.camera_trackers[camera_id]
+            logger.info(f"Reset tracking for camera {camera_id}")
+
+    def reset_all(self):
+        """Reset all camera trackers"""
+        self.camera_trackers.clear()
+        logger.info("Reset all camera trackers")
\ No newline at end of file
diff --git a/core/tracking/integration.py b/core/tracking/integration.py
index a10acf8..2fba002 100644
--- a/core/tracking/integration.py
+++ b/core/tracking/integration.py
@@ -61,9 +61,10 @@ class TrackingPipelineIntegration:
         self.cleared_sessions: Dict[str, float] = {}  # session_id -> clear_time
         self.pending_vehicles: Dict[str, int] = {}  # display_id -> track_id (waiting for session ID)
         self.pending_processing_data: Dict[str, Dict] = {}  # display_id -> processing data (waiting for session ID)
+        self.display_to_subscription: Dict[str, str] = {}  # display_id -> subscription_id (for fallback)
 
         # Additional validators for enhanced flow control
-        self.permanently_processed: Dict[int, float] = {}  # track_id -> process_time (never process again)
+        self.permanently_processed: Dict[str, float] = {}  # "camera_id:track_id" -> process_time (never process again)
         self.progression_stages: Dict[str, str] = {}  # session_id -> current_stage
         self.last_detection_time: Dict[str, float] = {}  # display_id -> last_detection_timestamp
         self.abandonment_timeout = 3.0  # seconds to wait before declaring car abandoned
@@ -71,12 +72,17 @@ class TrackingPipelineIntegration:
         # Thread pool for pipeline execution
         self.executor = ThreadPoolExecutor(max_workers=2)
 
+        # Min bbox filtering configuration
+        # TODO: Make this configurable via pipeline.json in the future
+        self.min_bbox_area_percentage = 3.5  # 3.5% of frame area minimum
+
         # Statistics
         self.stats = {
             'frames_processed': 0,
             'vehicles_detected': 0,
             'vehicles_validated': 0,
-            'pipelines_executed': 0
+            'pipelines_executed': 0,
+            'frontals_filtered_small': 0  # Track filtered detections
         }
 
 
@@ -183,7 +189,7 @@ class TrackingPipelineIntegration:
 
             # Run tracking model
             if self.tracking_model:
-                # Run inference with tracking
+                # Run detection-only (tracking handled by our own tracker)
                 tracking_results = self.tracking_model.track(
                     frame,
                     confidence_threshold=self.tracker.min_confidence,
@@ -202,6 +208,10 @@ class TrackingPipelineIntegration:
                 else:
                     logger.debug(f"No tracking results or detections attribute")
 
+                # Filter out small frontal detections (neighboring pumps/distant cars)
+                if tracking_results and hasattr(tracking_results, 'detections'):
+                    tracking_results = self._filter_small_frontals(tracking_results, frame)
+
                 # Process tracking results
                 tracked_vehicles = self.tracker.process_detections(
                     tracking_results,
@@ -210,8 +220,10 @@ class TrackingPipelineIntegration:
                 )
 
                 # Update last detection time for abandonment detection
+                # Update when vehicles ARE detected, so when they leave, timestamp ages
                 if tracked_vehicles:
                     self.last_detection_time[display_id] = time.time()
+                    logger.debug(f"Updated last_detection_time for {display_id}: {len(tracked_vehicles)} vehicles")
 
                 # Check for car abandonment (vehicle left after getting car_wait_staff stage)
                 await self._check_car_abandonment(display_id, subscription_id)
@@ -402,27 +414,12 @@ class TrackingPipelineIntegration:
             logger.info(f"Executing processing phase for session {session_id}, vehicle {vehicle.track_id}")
 
             # Capture high-quality snapshot for pipeline processing
-            frame = None
-            if self.subscription_info and self.subscription_info.stream_config.snapshot_url:
-                from ..streaming.readers import HTTPSnapshotReader
+            logger.info(f"[PROCESSING PHASE] Fetching 2K snapshot for session {session_id}")
+            frame = self._fetch_snapshot()
 
-                logger.info(f"[PROCESSING PHASE] Fetching 2K snapshot for session {session_id}")
-                snapshot_reader = HTTPSnapshotReader(
-                    camera_id=self.subscription_info.camera_id,
-                    snapshot_url=self.subscription_info.stream_config.snapshot_url,
-                    max_retries=3
-                )
-
-                frame = snapshot_reader.fetch_single_snapshot()
-
-                if frame is not None:
-                    logger.info(f"[PROCESSING PHASE] Successfully fetched {frame.shape[1]}x{frame.shape[0]} snapshot for pipeline")
-                else:
-                    logger.warning(f"[PROCESSING PHASE] Failed to capture snapshot, falling back to RTSP frame")
-                    # Fall back to RTSP frame if snapshot fails
-                    frame = processing_data['frame']
-            else:
-                logger.warning(f"[PROCESSING PHASE] No snapshot URL available, using RTSP frame")
+            if frame is None:
+                logger.warning(f"[PROCESSING PHASE] Failed to capture snapshot, falling back to RTSP frame")
+                # Fall back to RTSP frame if snapshot fails
                 frame = processing_data['frame']
 
             # Extract detected regions from detection phase result if available
@@ -465,7 +462,7 @@ class TrackingPipelineIntegration:
         self.subscription_info = subscription_info
         logger.debug(f"Set subscription info with snapshot_url: {subscription_info.stream_config.snapshot_url if subscription_info else None}")
 
-    def set_session_id(self, display_id: str, session_id: str):
+    def set_session_id(self, display_id: str, session_id: str, subscription_id: str = None):
         """
         Set session ID for a display (from backend).
         This is called when backend sends setSessionId after receiving imageDetection.
@@ -473,9 +470,18 @@ class TrackingPipelineIntegration:
         Args:
             display_id: Display identifier
             session_id: Session identifier
+            subscription_id: Subscription identifier (displayId;cameraId) - needed for fallback
         """
+        # Ensure session_id is always a string for consistent type handling
+        session_id = str(session_id) if session_id is not None else None
         self.active_sessions[display_id] = session_id
-        logger.info(f"Set session {session_id} for display {display_id}")
+
+        # Store subscription_id for fallback usage
+        if subscription_id:
+            self.display_to_subscription[display_id] = subscription_id
+            logger.info(f"Set session {session_id} for display {display_id} with subscription {subscription_id}")
+        else:
+            logger.info(f"Set session {session_id} for display {display_id}")
 
         # Check if we have a pending vehicle for this display
         if display_id in self.pending_vehicles:
@@ -486,7 +492,10 @@ class TrackingPipelineIntegration:
             self.session_vehicles[session_id] = track_id
 
             # Mark vehicle as permanently processed (won't process again even after session clear)
-            self.permanently_processed[track_id] = time.time()
+            # Use composite key to distinguish same track IDs across different cameras
+            camera_id = display_id  # Using display_id as camera_id for isolation
+            permanent_key = f"{camera_id}:{track_id}"
+            self.permanently_processed[permanent_key] = time.time()
 
             # Remove from pending
             del self.pending_vehicles[display_id]
@@ -513,6 +522,25 @@ class TrackingPipelineIntegration:
         else:
             logger.warning(f"No pending processing data found for display {display_id} when setting session {session_id}")
 
+            # FALLBACK: Execute pipeline for POS-initiated sessions
+            # Skip if session_id is None (no car present or car has left)
+            if session_id is not None:
+                # Use stored subscription_id instead of creating fake one
+                stored_subscription_id = self.display_to_subscription.get(display_id)
+                if stored_subscription_id:
+                    logger.info(f"[FALLBACK] Triggering fallback pipeline for session {session_id} on display {display_id} with subscription {stored_subscription_id}")
+
+                    # Trigger the fallback pipeline asynchronously with real subscription_id
+                    asyncio.create_task(self._execute_fallback_pipeline(
+                        display_id=display_id,
+                        session_id=session_id,
+                        subscription_id=stored_subscription_id
+                    ))
+                else:
+                    logger.error(f"[FALLBACK] No subscription_id stored for display {display_id}, cannot execute fallback pipeline")
+            else:
+                logger.debug(f"[FALLBACK] Skipping pipeline execution for session_id=None on display {display_id}")
+
     def clear_session_id(self, session_id: str):
         """
         Clear session ID (post-fueling).
@@ -562,6 +590,7 @@ class TrackingPipelineIntegration:
         self.cleared_sessions.clear()
         self.pending_vehicles.clear()
         self.pending_processing_data.clear()
+        self.display_to_subscription.clear()
         self.permanently_processed.clear()
         self.progression_stages.clear()
         self.last_detection_time.clear()
@@ -605,10 +634,16 @@ class TrackingPipelineIntegration:
                     last_detection = self.last_detection_time.get(session_display, 0)
                     time_since_detection = current_time - last_detection
 
+                    logger.info(f"[ABANDON CHECK] Session {session_id} (display: {session_display}): "
+                              f"time_since_detection={time_since_detection:.1f}s, "
+                              f"timeout={self.abandonment_timeout}s")
+
                     if time_since_detection > self.abandonment_timeout:
-                        logger.info(f"Car abandonment detected: session {session_id}, "
+                        logger.warning(f"🚨 Car abandonment detected: session {session_id}, "
                                   f"no detection for {time_since_detection:.1f}s")
                         abandoned_sessions.append(session_id)
+                else:
+                    logger.debug(f"[ABANDON CHECK] Session {session_id} has no associated display")
 
         # Send abandonment detection for each abandoned session
         for session_id in abandoned_sessions:
@@ -616,6 +651,7 @@ class TrackingPipelineIntegration:
             # Remove from progression stages to avoid repeated detection
             if session_id in self.progression_stages:
                 del self.progression_stages[session_id]
+                logger.info(f"[ABANDON] Removed session {session_id} from progression_stages after notification")
 
     async def _send_abandonment_detection(self, subscription_id: str, session_id: str):
         """
@@ -662,11 +698,159 @@ class TrackingPipelineIntegration:
         if stage == "car_wait_staff":
             logger.info(f"Started monitoring session {session_id} for car abandonment")
 
+    def _fetch_snapshot(self) -> Optional[np.ndarray]:
+        """
+        Fetch high-quality snapshot from camera's snapshot URL.
+        Reusable method for both processing phase and fallback pipeline.
+
+        Returns:
+            Snapshot frame or None if unavailable
+        """
+        if not (self.subscription_info and self.subscription_info.stream_config.snapshot_url):
+            logger.warning("[SNAPSHOT] No subscription info or snapshot URL available")
+            return None
+
+        try:
+            from ..streaming.readers import HTTPSnapshotReader
+
+            logger.info(f"[SNAPSHOT] Fetching snapshot for {self.subscription_info.camera_id}")
+            snapshot_reader = HTTPSnapshotReader(
+                camera_id=self.subscription_info.camera_id,
+                snapshot_url=self.subscription_info.stream_config.snapshot_url,
+                max_retries=3
+            )
+
+            frame = snapshot_reader.fetch_single_snapshot()
+
+            if frame is not None:
+                logger.info(f"[SNAPSHOT] Successfully fetched {frame.shape[1]}x{frame.shape[0]} snapshot")
+                return frame
+            else:
+                logger.warning("[SNAPSHOT] Failed to fetch snapshot")
+                return None
+
+        except Exception as e:
+            logger.error(f"[SNAPSHOT] Error fetching snapshot: {e}", exc_info=True)
+            return None
+
+    async def _execute_fallback_pipeline(self, display_id: str, session_id: str, subscription_id: str):
+        """
+        Execute fallback pipeline when sessionId is received without prior detection.
+        This handles POS-initiated sessions where backend starts transaction before car detection.
+
+        Args:
+            display_id: Display identifier
+            session_id: Session ID from backend
+            subscription_id: Subscription identifier for pipeline execution
+        """
+        try:
+            logger.info(f"[FALLBACK PIPELINE] Executing for session {session_id}, display {display_id}")
+
+            # Fetch fresh snapshot from camera
+            frame = self._fetch_snapshot()
+
+            if frame is None:
+                logger.error(f"[FALLBACK] Failed to fetch snapshot for session {session_id}, cannot execute pipeline")
+                return
+
+            logger.info(f"[FALLBACK] Using snapshot frame {frame.shape[1]}x{frame.shape[0]} for session {session_id}")
+
+            # Check if detection pipeline is available
+            if not self.detection_pipeline:
+                logger.error(f"[FALLBACK] Detection pipeline not available for session {session_id}")
+                return
+
+            # Execute detection phase to get detected regions
+            detection_result = await self.detection_pipeline.execute_detection_phase(
+                frame=frame,
+                display_id=display_id,
+                subscription_id=subscription_id
+            )
+
+            logger.info(f"[FALLBACK] Detection phase completed for session {session_id}: "
+                       f"status={detection_result.get('status', 'unknown')}, "
+                       f"regions={list(detection_result.get('detected_regions', {}).keys())}")
+
+            # If detection found regions, execute processing phase
+            detected_regions = detection_result.get('detected_regions', {})
+            if detected_regions:
+                processing_result = await self.detection_pipeline.execute_processing_phase(
+                    frame=frame,
+                    display_id=display_id,
+                    session_id=session_id,
+                    subscription_id=subscription_id,
+                    detected_regions=detected_regions
+                )
+
+                logger.info(f"[FALLBACK] Processing phase completed for session {session_id}: "
+                           f"status={processing_result.get('status', 'unknown')}, "
+                           f"branches={len(processing_result.get('branch_results', {}))}, "
+                           f"actions={len(processing_result.get('actions_executed', []))}")
+
+                # Update statistics
+                self.stats['pipelines_executed'] += 1
+
+            else:
+                logger.warning(f"[FALLBACK] No detections found in snapshot for session {session_id}")
+
+        except Exception as e:
+            logger.error(f"[FALLBACK] Error executing fallback pipeline for session {session_id}: {e}", exc_info=True)
+
+    def _filter_small_frontals(self, tracking_results, frame):
+        """
+        Filter out frontal detections that are smaller than minimum bbox area percentage.
+        This prevents processing of cars from neighboring pumps that appear in camera view.
+
+        Args:
+            tracking_results: YOLO tracking results with detections
+            frame: Input frame for calculating frame area
+
+        Returns:
+            Modified tracking_results with small frontals removed
+        """
+        if not hasattr(tracking_results, 'detections') or not tracking_results.detections:
+            return tracking_results
+
+        # Calculate frame area and minimum bbox area threshold
+        frame_area = frame.shape[0] * frame.shape[1]  # height * width
+        min_bbox_area = frame_area * (self.min_bbox_area_percentage / 100.0)
+
+        # Filter detections
+        filtered_detections = []
+        filtered_count = 0
+
+        for detection in tracking_results.detections:
+            # Calculate detection bbox area
+            bbox = detection.bbox  # Assuming bbox is [x1, y1, x2, y2]
+            bbox_area = (bbox[2] - bbox[0]) * (bbox[3] - bbox[1])
+
+            if bbox_area >= min_bbox_area:
+                # Keep detection - bbox is large enough
+                filtered_detections.append(detection)
+            else:
+                # Filter out small detection
+                filtered_count += 1
+                area_percentage = (bbox_area / frame_area) * 100
+                logger.debug(f"Filtered small frontal: area={bbox_area:.0f}px² ({area_percentage:.1f}% of frame, "
+                           f"min required: {self.min_bbox_area_percentage}%)")
+
+        # Update tracking results with filtered detections
+        tracking_results.detections = filtered_detections
+
+        # Update statistics
+        if filtered_count > 0:
+            self.stats['frontals_filtered_small'] += filtered_count
+            logger.info(f"Filtered {filtered_count} small frontal detections, "
+                       f"{len(filtered_detections)} remaining (total filtered: {self.stats['frontals_filtered_small']})")
+
+        return tracking_results
+
     def cleanup(self):
         """Cleanup resources."""
         self.executor.shutdown(wait=False)
         self.reset_tracking()
 
+
         # Cleanup detection pipeline
         if self.detection_pipeline:
             self.detection_pipeline.cleanup()
diff --git a/core/tracking/tracker.py b/core/tracking/tracker.py
index 104343b..63d0299 100644
--- a/core/tracking/tracker.py
+++ b/core/tracking/tracker.py
@@ -1,6 +1,6 @@
 """
-Vehicle Tracking Module - Continuous tracking with front_rear_detection model
-Implements vehicle identification, persistence, and motion analysis.
+Vehicle Tracking Module - BoT-SORT based tracking with camera isolation
+Implements vehicle identification, persistence, and motion analysis using external tracker.
 """
 import logging
 import time
@@ -10,6 +10,8 @@ from dataclasses import dataclass, field
 import numpy as np
 from threading import Lock
 
+from .bot_sort_tracker import MultiCameraBoTSORT
+
 logger = logging.getLogger(__name__)
 
 
@@ -17,6 +19,7 @@ logger = logging.getLogger(__name__)
 class TrackedVehicle:
     """Represents a tracked vehicle with all its state information."""
     track_id: int
+    camera_id: str
     first_seen: float
     last_seen: float
     session_id: Optional[str] = None
@@ -30,126 +33,43 @@ class TrackedVehicle:
     processed_pipeline: bool = False
     last_position_history: List[Tuple[float, float]] = field(default_factory=list)
     avg_confidence: float = 0.0
+    hit_streak: int = 0
+    age: int = 0
 
-    # Hybrid validation fields
-    track_id_changes: int = 0  # Number of times track ID changed for same position
-    position_stability_score: float = 0.0  # Independent position-based stability
-    continuous_stable_duration: float = 0.0  # Time continuously stable (ignoring track ID changes)
-    last_track_id_change: Optional[float] = None  # When track ID last changed
-    original_track_id: int = None  # First track ID seen at this position
-
-    def update_position(self, bbox: Tuple[int, int, int, int], confidence: float, new_track_id: Optional[int] = None):
+    def update_position(self, bbox: Tuple[int, int, int, int], confidence: float):
         """Update vehicle position and confidence."""
         self.bbox = bbox
         self.center = ((bbox[0] + bbox[2]) / 2, (bbox[1] + bbox[3]) / 2)
-        current_time = time.time()
-        self.last_seen = current_time
+        self.last_seen = time.time()
         self.confidence = confidence
         self.total_frames += 1
 
-        # Track ID change detection
-        if new_track_id is not None and new_track_id != self.track_id:
-            self.track_id_changes += 1
-            self.last_track_id_change = current_time
-            logger.debug(f"Track ID changed from {self.track_id} to {new_track_id} for same vehicle")
-            self.track_id = new_track_id
-
-        # Set original track ID if not set
-        if self.original_track_id is None:
-            self.original_track_id = self.track_id
-
         # Update confidence average
         self.avg_confidence = ((self.avg_confidence * (self.total_frames - 1)) + confidence) / self.total_frames
 
-        # Maintain position history (last 15 positions for better stability analysis)
+        # Maintain position history (last 10 positions)
         self.last_position_history.append(self.center)
-        if len(self.last_position_history) > 15:
+        if len(self.last_position_history) > 10:
             self.last_position_history.pop(0)
 
-        # Update position-based stability
-        self._update_position_stability()
-
-    def _update_position_stability(self):
-        """Update position-based stability score independent of track ID."""
-        if len(self.last_position_history) < 5:
-            self.position_stability_score = 0.0
-            return
-
-        positions = np.array(self.last_position_history)
-
-        # Calculate position variance (lower = more stable)
-        std_x = np.std(positions[:, 0])
-        std_y = np.std(positions[:, 1])
-
-        # Calculate movement velocity
-        if len(positions) >= 3:
-            recent_movement = np.mean([
-                np.sqrt((positions[i][0] - positions[i-1][0])**2 +
-                       (positions[i][1] - positions[i-1][1])**2)
-                for i in range(-3, 0)
-            ])
-        else:
-            recent_movement = 0
-
-        # Position-based stability (0-1 where 1 = perfectly stable)
-        max_reasonable_std = 150  # For HD resolution
-        variance_score = max(0, 1 - (std_x + std_y) / max_reasonable_std)
-        velocity_score = max(0, 1 - recent_movement / 20)  # 20 pixels max reasonable movement
-
-        self.position_stability_score = (variance_score * 0.7 + velocity_score * 0.3)
-
-        # Update continuous stable duration
-        if self.position_stability_score > 0.7:
-            if self.continuous_stable_duration == 0:
-                # Start tracking stable duration
-                self.continuous_stable_duration = 0.1  # Small initial value
-            else:
-                # Continue tracking
-                self.continuous_stable_duration = time.time() - self.first_seen
-        else:
-            # Reset if not stable
-            self.continuous_stable_duration = 0.0
-
     def calculate_stability(self) -> float:
         """Calculate stability score based on position history."""
-        return self.position_stability_score
+        if len(self.last_position_history) < 2:
+            return 0.0
 
-    def calculate_hybrid_stability(self) -> Tuple[float, str]:
-        """
-        Calculate hybrid stability considering both track ID continuity and position stability.
+        # Calculate movement variance
+        positions = np.array(self.last_position_history)
+        if len(positions) < 2:
+            return 0.0
 
-        Returns:
-            Tuple of (stability_score, reasoning)
-        """
-        if len(self.last_position_history) < 5:
-            return 0.0, "Insufficient position history"
+        # Calculate standard deviation of positions
+        std_x = np.std(positions[:, 0])
+        std_y = np.std(positions[:, 1])
 
-        position_stable = self.position_stability_score > 0.7
-        has_stable_duration = self.continuous_stable_duration > 2.0  # 2+ seconds stable
-        recent_track_change = (self.last_track_id_change is not None and
-                             (time.time() - self.last_track_id_change) < 1.0)
-
-        # Base stability from position
-        base_score = self.position_stability_score
-
-        # Penalties and bonuses
-        if self.track_id_changes > 3:
-            # Too many track ID changes - likely tracking issues
-            base_score *= 0.8
-            reason = f"Multiple track ID changes ({self.track_id_changes})"
-        elif recent_track_change:
-            # Recent track change - be cautious
-            base_score *= 0.9
-            reason = "Recent track ID change"
-        else:
-            reason = "Position-based stability"
-
-        # Bonus for long continuous stability regardless of track ID changes
-        if has_stable_duration:
-            base_score = min(1.0, base_score + 0.1)
-            reason += f" + {self.continuous_stable_duration:.1f}s continuous"
-
-        return base_score, reason
+        # Lower variance means more stable (inverse relationship)
+        # Normalize to 0-1 range (assuming max reasonable std is 50 pixels)
+        stability = max(0, 1 - (std_x + std_y) / 100)
+        return stability
 
     def is_expired(self, timeout_seconds: float = 2.0) -> bool:
         """Check if vehicle tracking has expired."""
@@ -158,7 +78,7 @@ class TrackedVehicle:
 
 class VehicleTracker:
     """
-    Main vehicle tracking implementation using YOLO tracking capabilities.
+    Main vehicle tracking implementation using BoT-SORT with camera isolation.
     Manages continuous tracking, vehicle identification, and state persistence.
     """
 
@@ -173,19 +93,19 @@ class VehicleTracker:
         self.trigger_classes = self.config.get('trigger_classes', self.config.get('triggerClasses', ['frontal']))
         self.min_confidence = self.config.get('minConfidence', 0.6)
 
-        # Tracking state
-        self.tracked_vehicles: Dict[int, TrackedVehicle] = {}
-        self.position_registry: Dict[str, TrackedVehicle] = {}  # Position-based vehicle registry
-        self.next_track_id = 1
+        # BoT-SORT multi-camera tracker
+        self.bot_sort = MultiCameraBoTSORT(self.trigger_classes, self.min_confidence)
+
+        # Tracking state - maintain compatibility with existing code
+        self.tracked_vehicles: Dict[str, Dict[int, TrackedVehicle]] = {}  # camera_id -> {track_id: vehicle}
         self.lock = Lock()
 
         # Tracking parameters
-        self.stability_threshold = 0.65  # Lowered for gas station scenarios
-        self.min_stable_frames = 8  # Increased for 4fps processing
-        self.position_tolerance = 80  # pixels - increased for gas station scenarios
-        self.timeout_seconds = 8.0  # Increased for gas station scenarios
+        self.stability_threshold = 0.7
+        self.min_stable_frames = 5
+        self.timeout_seconds = 2.0
 
-        logger.info(f"VehicleTracker initialized with trigger_classes={self.trigger_classes}, "
+        logger.info(f"VehicleTracker initialized with BoT-SORT: trigger_classes={self.trigger_classes}, "
                    f"min_confidence={self.min_confidence}")
 
     def process_detections(self,
@@ -193,10 +113,10 @@ class VehicleTracker:
                           display_id: str,
                           frame: np.ndarray) -> List[TrackedVehicle]:
         """
-        Process YOLO detection results and update tracking state.
+        Process detection results using BoT-SORT tracking.
 
         Args:
-            results: YOLO detection results with tracking
+            results: Detection results (InferenceResult)
             display_id: Display identifier for this stream
             frame: Current frame being processed
 
@@ -204,172 +124,67 @@ class VehicleTracker:
             List of currently tracked vehicles
         """
         current_time = time.time()
-        active_tracks = []
+
+        # Extract camera_id from display_id for tracking isolation
+        camera_id = display_id  # Using display_id as camera_id for isolation
 
         with self.lock:
-            # Clean up expired tracks
-            expired_ids = [
-                track_id for track_id, vehicle in self.tracked_vehicles.items()
-                if vehicle.is_expired(self.timeout_seconds)
-            ]
-            for track_id in expired_ids:
-                vehicle = self.tracked_vehicles[track_id]
-                # Remove from position registry too
-                position_key = self._get_position_key(vehicle.center)
-                if position_key in self.position_registry and self.position_registry[position_key] == vehicle:
-                    del self.position_registry[position_key]
-                logger.debug(f"Removing expired track {track_id}")
-                del self.tracked_vehicles[track_id]
+            # Update BoT-SORT tracker
+            track_results = self.bot_sort.update(camera_id, results)
 
-            # Process new detections from InferenceResult
-            if hasattr(results, 'detections') and results.detections:
-                # Process detections from InferenceResult
-                for detection in results.detections:
-                    # Skip if confidence is too low
-                    if detection.confidence < self.min_confidence:
-                        continue
+            # Ensure camera tracking dict exists
+            if camera_id not in self.tracked_vehicles:
+                self.tracked_vehicles[camera_id] = {}
 
-                    # Check if class is in trigger classes
-                    if detection.class_name not in self.trigger_classes:
-                        continue
+            # Update tracked vehicles based on BoT-SORT results
+            current_tracks = {}
+            active_tracks = []
 
-                    # Get bounding box and center from Detection object
-                    x1, y1, x2, y2 = detection.bbox
-                    bbox = (int(x1), int(y1), int(x2), int(y2))
-                    center = ((x1 + x2) / 2, (y1 + y2) / 2)
-                    confidence = detection.confidence
+            for track_result in track_results:
+                track_id = track_result['track_id']
 
-                    # Hybrid approach: Try position-based association first, then track ID
-                    track_id = detection.track_id
-                    existing_vehicle = None
-                    position_key = self._get_position_key(center)
+                # Create or update TrackedVehicle
+                if track_id in self.tracked_vehicles[camera_id]:
+                    # Update existing vehicle
+                    vehicle = self.tracked_vehicles[camera_id][track_id]
+                    vehicle.update_position(track_result['bbox'], track_result['confidence'])
+                    vehicle.hit_streak = track_result['hit_streak']
+                    vehicle.age = track_result['age']
 
-                    # 1. Check position registry first (same physical location)
-                    if position_key in self.position_registry:
-                        existing_vehicle = self.position_registry[position_key]
-                        if track_id is not None and track_id != existing_vehicle.track_id:
-                            # Track ID changed for same position - update vehicle
-                            existing_vehicle.update_position(bbox, confidence, track_id)
-                            logger.debug(f"Track ID changed {existing_vehicle.track_id}->{track_id} at same position")
-                            # Update tracking dict
-                            if existing_vehicle.track_id in self.tracked_vehicles:
-                                del self.tracked_vehicles[existing_vehicle.track_id]
-                            self.tracked_vehicles[track_id] = existing_vehicle
-                        else:
-                            # Same position, same/no track ID
-                            existing_vehicle.update_position(bbox, confidence)
-                        track_id = existing_vehicle.track_id
+                    # Update stability based on hit_streak
+                    if vehicle.hit_streak >= self.min_stable_frames:
+                        vehicle.is_stable = True
+                        vehicle.stable_frames = vehicle.hit_streak
 
-                    # 2. If no position match, try track ID approach
-                    elif track_id is not None and track_id in self.tracked_vehicles:
-                        # Existing track ID, check if position moved significantly
-                        existing_vehicle = self.tracked_vehicles[track_id]
-                        old_position_key = self._get_position_key(existing_vehicle.center)
+                    logger.debug(f"Updated track {track_id}: conf={vehicle.confidence:.2f}, "
+                               f"stable={vehicle.is_stable}, hit_streak={vehicle.hit_streak}")
+                else:
+                    # Create new vehicle
+                    x1, y1, x2, y2 = track_result['bbox']
+                    vehicle = TrackedVehicle(
+                        track_id=track_id,
+                        camera_id=camera_id,
+                        first_seen=current_time,
+                        last_seen=current_time,
+                        display_id=display_id,
+                        confidence=track_result['confidence'],
+                        bbox=tuple(track_result['bbox']),
+                        center=((x1 + x2) / 2, (y1 + y2) / 2),
+                        total_frames=1,
+                        hit_streak=track_result['hit_streak'],
+                        age=track_result['age']
+                    )
+                    vehicle.last_position_history.append(vehicle.center)
+                    logger.info(f"New vehicle tracked: ID={track_id}, camera={camera_id}, display={display_id}")
 
-                        # If position moved significantly, update position registry
-                        if old_position_key != position_key:
-                            if old_position_key in self.position_registry:
-                                del self.position_registry[old_position_key]
-                            self.position_registry[position_key] = existing_vehicle
+                current_tracks[track_id] = vehicle
+                active_tracks.append(vehicle)
 
-                        existing_vehicle.update_position(bbox, confidence)
-
-                    # 3. Try closest track association (fallback)
-                    elif track_id is None:
-                        closest_track = self._find_closest_track(center)
-                        if closest_track:
-                            existing_vehicle = closest_track
-                            track_id = closest_track.track_id
-                            existing_vehicle.update_position(bbox, confidence)
-                            # Update position registry
-                            self.position_registry[position_key] = existing_vehicle
-                            logger.debug(f"Associated detection with existing track {track_id} based on proximity")
-
-                    # 4. Create new vehicle if no associations found
-                    if existing_vehicle is None:
-                        track_id = track_id if track_id is not None else self.next_track_id
-                        if track_id == self.next_track_id:
-                            self.next_track_id += 1
-
-                        existing_vehicle = TrackedVehicle(
-                            track_id=track_id,
-                            first_seen=current_time,
-                            last_seen=current_time,
-                            display_id=display_id,
-                            confidence=confidence,
-                            bbox=bbox,
-                            center=center,
-                            total_frames=1,
-                            original_track_id=track_id
-                        )
-                        existing_vehicle.last_position_history.append(center)
-                        self.tracked_vehicles[track_id] = existing_vehicle
-                        self.position_registry[position_key] = existing_vehicle
-                        logger.info(f"New vehicle tracked: ID={track_id}, display={display_id}")
-
-                    # Check stability using hybrid approach
-                    stability_score, reason = existing_vehicle.calculate_hybrid_stability()
-                    if stability_score > self.stability_threshold:
-                        existing_vehicle.stable_frames += 1
-                        if existing_vehicle.stable_frames >= self.min_stable_frames:
-                            existing_vehicle.is_stable = True
-                    else:
-                        existing_vehicle.stable_frames = max(0, existing_vehicle.stable_frames - 1)
-                        if existing_vehicle.stable_frames < self.min_stable_frames:
-                            existing_vehicle.is_stable = False
-
-                    logger.debug(f"Updated track {track_id}: conf={confidence:.2f}, "
-                               f"stable={existing_vehicle.is_stable}, hybrid_stability={stability_score:.2f} ({reason})")
-
-                    active_tracks.append(existing_vehicle)
+            # Update the camera's tracked vehicles
+            self.tracked_vehicles[camera_id] = current_tracks
 
         return active_tracks
 
-    def _get_position_key(self, center: Tuple[float, float]) -> str:
-        """
-        Generate a position-based key for vehicle registry.
-        Groups nearby positions into the same key for association.
-
-        Args:
-            center: Center position (x, y)
-
-        Returns:
-            Position key string
-        """
-        # Grid-based quantization - 60 pixel grid for gas station scenarios
-        grid_size = 60
-        grid_x = int(center[0] // grid_size)
-        grid_y = int(center[1] // grid_size)
-        return f"{grid_x}_{grid_y}"
-
-    def _find_closest_track(self, center: Tuple[float, float]) -> Optional[TrackedVehicle]:
-        """
-        Find the closest existing track to a given position.
-
-        Args:
-            center: Center position to match
-
-        Returns:
-            Closest tracked vehicle if within tolerance, None otherwise
-        """
-        min_distance = float('inf')
-        closest_track = None
-
-        for vehicle in self.tracked_vehicles.values():
-            if vehicle.is_expired(1.0):  # Allow slightly older tracks for matching
-                continue
-
-            distance = np.sqrt(
-                (center[0] - vehicle.center[0]) ** 2 +
-                (center[1] - vehicle.center[1]) ** 2
-            )
-
-            if distance < min_distance and distance < self.position_tolerance:
-                min_distance = distance
-                closest_track = vehicle
-
-        return closest_track
-
     def get_stable_vehicles(self, display_id: Optional[str] = None) -> List[TrackedVehicle]:
         """
         Get all stable vehicles, optionally filtered by display.
@@ -381,11 +196,15 @@ class VehicleTracker:
             List of stable tracked vehicles
         """
         with self.lock:
-            stable = [
-                v for v in self.tracked_vehicles.values()
-                if v.is_stable and not v.is_expired(self.timeout_seconds)
-                and (display_id is None or v.display_id == display_id)
-            ]
+            stable = []
+            camera_id = display_id  # Using display_id as camera_id
+
+            if camera_id in self.tracked_vehicles:
+                for vehicle in self.tracked_vehicles[camera_id].values():
+                    if (vehicle.is_stable and not vehicle.is_expired(self.timeout_seconds) and
+                        (display_id is None or vehicle.display_id == display_id)):
+                        stable.append(vehicle)
+
         return stable
 
     def get_vehicle_by_session(self, session_id: str) -> Optional[TrackedVehicle]:
@@ -399,9 +218,11 @@ class VehicleTracker:
             Tracked vehicle if found, None otherwise
         """
         with self.lock:
-            for vehicle in self.tracked_vehicles.values():
-                if vehicle.session_id == session_id:
-                    return vehicle
+            # Search across all cameras
+            for camera_vehicles in self.tracked_vehicles.values():
+                for vehicle in camera_vehicles.values():
+                    if vehicle.session_id == session_id:
+                        return vehicle
         return None
 
     def mark_processed(self, track_id: int, session_id: str):
@@ -413,11 +234,14 @@ class VehicleTracker:
             session_id: Session ID assigned to this vehicle
         """
         with self.lock:
-            if track_id in self.tracked_vehicles:
-                vehicle = self.tracked_vehicles[track_id]
-                vehicle.processed_pipeline = True
-                vehicle.session_id = session_id
-                logger.info(f"Marked vehicle {track_id} as processed with session {session_id}")
+            # Search across all cameras for the track_id
+            for camera_vehicles in self.tracked_vehicles.values():
+                if track_id in camera_vehicles:
+                    vehicle = camera_vehicles[track_id]
+                    vehicle.processed_pipeline = True
+                    vehicle.session_id = session_id
+                    logger.info(f"Marked vehicle {track_id} as processed with session {session_id}")
+                    return
 
     def clear_session(self, session_id: str):
         """
@@ -427,31 +251,43 @@ class VehicleTracker:
             session_id: Session ID to clear
         """
         with self.lock:
-            for vehicle in self.tracked_vehicles.values():
-                if vehicle.session_id == session_id:
-                    logger.info(f"Clearing session {session_id} from vehicle {vehicle.track_id}")
-                    vehicle.session_id = None
-                    # Keep processed_pipeline=True to prevent re-processing
+            # Search across all cameras
+            for camera_vehicles in self.tracked_vehicles.values():
+                for vehicle in camera_vehicles.values():
+                    if vehicle.session_id == session_id:
+                        logger.info(f"Clearing session {session_id} from vehicle {vehicle.track_id}")
+                        vehicle.session_id = None
+                        # Keep processed_pipeline=True to prevent re-processing
 
     def reset_tracking(self):
         """Reset all tracking state."""
         with self.lock:
             self.tracked_vehicles.clear()
-            self.position_registry.clear()
-            self.next_track_id = 1
+            self.bot_sort.reset_all()
             logger.info("Vehicle tracking state reset")
 
     def get_statistics(self) -> Dict:
         """Get tracking statistics."""
         with self.lock:
-            total = len(self.tracked_vehicles)
-            stable = sum(1 for v in self.tracked_vehicles.values() if v.is_stable)
-            processed = sum(1 for v in self.tracked_vehicles.values() if v.processed_pipeline)
+            total = 0
+            stable = 0
+            processed = 0
+            all_confidences = []
+
+            # Aggregate stats across all cameras
+            for camera_vehicles in self.tracked_vehicles.values():
+                total += len(camera_vehicles)
+                for vehicle in camera_vehicles.values():
+                    if vehicle.is_stable:
+                        stable += 1
+                    if vehicle.processed_pipeline:
+                        processed += 1
+                    all_confidences.append(vehicle.avg_confidence)
 
             return {
                 'total_tracked': total,
                 'stable_vehicles': stable,
                 'processed_vehicles': processed,
-                'avg_confidence': np.mean([v.avg_confidence for v in self.tracked_vehicles.values()])
-                if self.tracked_vehicles else 0.0
+                'avg_confidence': np.mean(all_confidences) if all_confidences else 0.0,
+                'bot_sort_stats': self.bot_sort.get_statistics()
             }
\ No newline at end of file
diff --git a/core/tracking/validator.py b/core/tracking/validator.py
index 11f14b1..d86a3f6 100644
--- a/core/tracking/validator.py
+++ b/core/tracking/validator.py
@@ -36,8 +36,14 @@ class ValidationResult:
 
 class StableCarValidator:
     """
-    Validates whether a tracked vehicle is stable (fueling) or just passing by.
-    Uses multiple criteria including position stability, duration, and movement patterns.
+    Validates whether a tracked vehicle should be processed through the pipeline.
+
+    Updated for BoT-SORT integration: Trusts the sophisticated BoT-SORT tracking algorithm
+    for stability determination and focuses on business logic validation:
+    - Duration requirements for processing
+    - Confidence thresholds
+    - Session management and cooldowns
+    - Camera isolation with composite keys
     """
 
     def __init__(self, config: Optional[Dict] = None):
@@ -51,8 +57,8 @@ class StableCarValidator:
 
         # Validation thresholds
         self.min_stable_duration = self.config.get('min_stable_duration', 3.0)  # seconds
-        self.min_stable_frames = self.config.get('min_stable_frames', 8)
-        self.position_variance_threshold = self.config.get('position_variance_threshold', 40.0)  # pixels - adjusted for HD
+        self.min_stable_frames = self.config.get('min_stable_frames', 10)
+        self.position_variance_threshold = self.config.get('position_variance_threshold', 25.0)  # pixels
         self.min_confidence = self.config.get('min_confidence', 0.7)
         self.velocity_threshold = self.config.get('velocity_threshold', 5.0)  # pixels/frame
         self.entering_zone_ratio = self.config.get('entering_zone_ratio', 0.3)  # 30% of frame
@@ -169,7 +175,10 @@ class StableCarValidator:
 
     def _determine_vehicle_state(self, vehicle: TrackedVehicle) -> VehicleState:
         """
-        Determine the current state of the vehicle based on movement patterns.
+        Determine the current state of the vehicle based on BoT-SORT tracking results.
+
+        BoT-SORT provides sophisticated tracking, so we trust its stability determination
+        and focus on business logic validation.
 
         Args:
             vehicle: The tracked vehicle
@@ -177,53 +186,44 @@ class StableCarValidator:
         Returns:
             Current vehicle state
         """
-        # Not enough data
-        if len(vehicle.last_position_history) < 3:
-            return VehicleState.UNKNOWN
-
-        # Calculate velocity
-        velocity = self._calculate_velocity(vehicle)
-
-        # Get position zones
-        x_position = vehicle.center[0] / self.frame_width
-        y_position = vehicle.center[1] / self.frame_height
-
-        # Check if vehicle is stable using hybrid approach
-        stability_score, stability_reason = vehicle.calculate_hybrid_stability()
-        if stability_score > 0.65 and velocity < self.velocity_threshold:
-            # Check if it's been stable long enough
+        # Trust BoT-SORT's stability determination
+        if vehicle.is_stable:
+            # Check if it's been stable long enough for processing
             duration = time.time() - vehicle.first_seen
-            if duration > self.min_stable_duration and vehicle.stable_frames >= self.min_stable_frames:
+            if duration >= self.min_stable_duration:
                 return VehicleState.STABLE
             else:
                 return VehicleState.ENTERING
 
-        # Check if vehicle is entering or leaving
+        # For non-stable vehicles, use simplified state determination
+        if len(vehicle.last_position_history) < 2:
+            return VehicleState.UNKNOWN
+
+        # Calculate velocity for movement classification
+        velocity = self._calculate_velocity(vehicle)
+
+        # Basic movement classification
         if velocity > self.velocity_threshold:
-            # Determine direction based on position history
-            positions = np.array(vehicle.last_position_history)
-            if len(positions) >= 2:
-                direction = positions[-1] - positions[0]
+            # Vehicle is moving - classify as passing by or entering/leaving
+            x_position = vehicle.center[0] / self.frame_width
 
-                # Entering: moving towards center
-                if x_position < self.entering_zone_ratio or x_position > (1 - self.entering_zone_ratio):
-                    if abs(direction[0]) > abs(direction[1]):  # Horizontal movement
-                        if (x_position < 0.5 and direction[0] > 0) or (x_position > 0.5 and direction[0] < 0):
-                            return VehicleState.ENTERING
+            # Simple heuristic: vehicles near edges are entering/leaving, center vehicles are passing
+            if x_position < 0.2 or x_position > 0.8:
+                return VehicleState.ENTERING
+            else:
+                return VehicleState.PASSING_BY
 
-                # Leaving: moving away from center
-                if 0.3 < x_position < 0.7:  # In center zone
-                    if abs(direction[0]) > abs(direction[1]):  # Horizontal movement
-                        if abs(direction[0]) > 10:  # Significant movement
-                            return VehicleState.LEAVING
-
-            return VehicleState.PASSING_BY
-
-        return VehicleState.UNKNOWN
+        # Low velocity but not marked stable by tracker - likely entering
+        return VehicleState.ENTERING
 
     def _validate_stable_vehicle(self, vehicle: TrackedVehicle) -> ValidationResult:
         """
-        Perform detailed validation of a stable vehicle.
+        Perform business logic validation of a stable vehicle.
+
+        Since BoT-SORT already determined the vehicle is stable, we focus on:
+        - Duration requirements for processing
+        - Confidence thresholds
+        - Business logic constraints
 
         Args:
             vehicle: The stable vehicle to validate
@@ -231,7 +231,7 @@ class StableCarValidator:
         Returns:
             Detailed validation result
         """
-        # Check duration
+        # Check duration (business requirement)
         duration = time.time() - vehicle.first_seen
         if duration < self.min_stable_duration:
             return ValidationResult(
@@ -243,18 +243,7 @@ class StableCarValidator:
                 track_id=vehicle.track_id
             )
 
-        # Check frame count
-        if vehicle.stable_frames < self.min_stable_frames:
-            return ValidationResult(
-                is_valid=False,
-                state=VehicleState.STABLE,
-                confidence=0.6,
-                reason=f"Not enough stable frames ({vehicle.stable_frames} < {self.min_stable_frames})",
-                should_process=False,
-                track_id=vehicle.track_id
-            )
-
-        # Check confidence
+        # Check confidence (business requirement)
         if vehicle.avg_confidence < self.min_confidence:
             return ValidationResult(
                 is_valid=False,
@@ -265,28 +254,19 @@ class StableCarValidator:
                 track_id=vehicle.track_id
             )
 
-        # Check position variance
-        variance = self._calculate_position_variance(vehicle)
-        if variance > self.position_variance_threshold:
-            return ValidationResult(
-                is_valid=False,
-                state=VehicleState.STABLE,
-                confidence=0.7,
-                reason=f"Position variance too high ({variance:.1f} > {self.position_variance_threshold})",
-                should_process=False,
-                track_id=vehicle.track_id
-            )
+        # Trust BoT-SORT's stability determination - skip position variance check
+        # BoT-SORT's sophisticated tracking already ensures consistent positioning
 
-        # Check state history consistency
+        # Simplified state history check - just ensure recent stability
         if vehicle.track_id in self.validation_history:
-            history = self.validation_history[vehicle.track_id][-5:]  # Last 5 states
+            history = self.validation_history[vehicle.track_id][-3:]  # Last 3 states
             stable_count = sum(1 for s in history if s == VehicleState.STABLE)
-            if stable_count < 3:
+            if len(history) >= 2 and stable_count == 0:  # Only fail if clear instability
                 return ValidationResult(
                     is_valid=False,
                     state=VehicleState.STABLE,
                     confidence=0.7,
-                    reason="Inconsistent state history",
+                    reason="Recent state history shows instability",
                     should_process=False,
                     track_id=vehicle.track_id
                 )
@@ -294,15 +274,11 @@ class StableCarValidator:
         # All checks passed - vehicle is valid for processing
         self.last_processed_vehicles[vehicle.track_id] = time.time()
 
-        # Get hybrid stability info for detailed reasoning
-        hybrid_stability, hybrid_reason = vehicle.calculate_hybrid_stability()
-        processing_reason = f"Vehicle is stable and ready for processing (hybrid: {hybrid_reason})"
-
         return ValidationResult(
             is_valid=True,
             state=VehicleState.STABLE,
             confidence=vehicle.avg_confidence,
-            reason=processing_reason,
+            reason="Vehicle is stable and ready for processing (BoT-SORT validated)",
             should_process=True,
             track_id=vehicle.track_id
         )
@@ -358,25 +334,28 @@ class StableCarValidator:
     def should_skip_same_car(self,
                             vehicle: TrackedVehicle,
                             session_cleared: bool = False,
-                            permanently_processed: Dict[int, float] = None) -> bool:
+                            permanently_processed: Dict[str, float] = None) -> bool:
         """
         Determine if we should skip processing for the same car after session clear.
 
         Args:
             vehicle: The tracked vehicle
             session_cleared: Whether the session was recently cleared
-            permanently_processed: Dict of permanently processed vehicles
+            permanently_processed: Dict of permanently processed vehicles (camera_id:track_id -> time)
 
         Returns:
             True if we should skip this vehicle
         """
         # Check if this vehicle was permanently processed (never process again)
-        if permanently_processed and vehicle.track_id in permanently_processed:
-            process_time = permanently_processed[vehicle.track_id]
-            time_since = time.time() - process_time
-            logger.debug(f"Skipping permanently processed vehicle {vehicle.track_id} "
-                        f"(processed {time_since:.1f}s ago)")
-            return True
+        if permanently_processed:
+            # Create composite key using camera_id and track_id
+            permanent_key = f"{vehicle.camera_id}:{vehicle.track_id}"
+            if permanent_key in permanently_processed:
+                process_time = permanently_processed[permanent_key]
+                time_since = time.time() - process_time
+                logger.debug(f"Skipping permanently processed vehicle {vehicle.track_id} on camera {vehicle.camera_id} "
+                            f"(processed {time_since:.1f}s ago)")
+                return True
 
         # If vehicle has a session_id but it was cleared, skip for a period
         if vehicle.session_id is None and vehicle.processed_pipeline and session_cleared:
diff --git a/core/utils/ffmpeg_detector.py b/core/utils/ffmpeg_detector.py
new file mode 100644
index 0000000..565713c
--- /dev/null
+++ b/core/utils/ffmpeg_detector.py
@@ -0,0 +1,214 @@
+"""
+FFmpeg hardware acceleration detection and configuration
+"""
+
+import subprocess
+import logging
+import re
+from typing import Dict, List, Optional
+
+logger = logging.getLogger("detector_worker")
+
+
+class FFmpegCapabilities:
+    """Detect and configure FFmpeg hardware acceleration capabilities."""
+
+    def __init__(self):
+        """Initialize FFmpeg capabilities detector."""
+        self.hwaccels = []
+        self.codecs = {}
+        self.nvidia_support = False
+        self.vaapi_support = False
+        self.qsv_support = False
+
+        self._detect_capabilities()
+
+    def _detect_capabilities(self):
+        """Detect available hardware acceleration methods."""
+        try:
+            # Get hardware accelerators
+            result = subprocess.run(
+                ['ffmpeg', '-hide_banner', '-hwaccels'],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                self.hwaccels = [line.strip() for line in result.stdout.strip().split('\n')[1:] if line.strip()]
+                logger.info(f"Available FFmpeg hardware accelerators: {', '.join(self.hwaccels)}")
+
+            # Check for NVIDIA support
+            self.nvidia_support = any(hw in self.hwaccels for hw in ['cuda', 'cuvid', 'nvdec'])
+            self.vaapi_support = 'vaapi' in self.hwaccels
+            self.qsv_support = 'qsv' in self.hwaccels
+
+            # Get decoder information
+            self._detect_decoders()
+
+            # Log capabilities
+            if self.nvidia_support:
+                logger.info("NVIDIA hardware acceleration available (CUDA/CUVID/NVDEC)")
+                logger.info(f"Detected hardware codecs: {self.codecs}")
+            if self.vaapi_support:
+                logger.info("VAAPI hardware acceleration available")
+            if self.qsv_support:
+                logger.info("Intel QuickSync hardware acceleration available")
+
+        except Exception as e:
+            logger.warning(f"Failed to detect FFmpeg capabilities: {e}")
+
+    def _detect_decoders(self):
+        """Detect available hardware decoders."""
+        try:
+            result = subprocess.run(
+                ['ffmpeg', '-hide_banner', '-decoders'],
+                capture_output=True, text=True, timeout=10
+            )
+            if result.returncode == 0:
+                # Parse decoder output to find hardware decoders
+                for line in result.stdout.split('\n'):
+                    if 'cuvid' in line or 'nvdec' in line:
+                        match = re.search(r'(\w+)\s+.*?(\w+(?:_cuvid|_nvdec))', line)
+                        if match:
+                            codec_type, decoder = match.groups()
+                            if 'h264' in decoder:
+                                self.codecs['h264_hw'] = decoder
+                            elif 'hevc' in decoder or 'h265' in decoder:
+                                self.codecs['h265_hw'] = decoder
+                    elif 'vaapi' in line:
+                        match = re.search(r'(\w+)\s+.*?(\w+_vaapi)', line)
+                        if match:
+                            codec_type, decoder = match.groups()
+                            if 'h264' in decoder:
+                                self.codecs['h264_vaapi'] = decoder
+
+        except Exception as e:
+            logger.debug(f"Failed to detect decoders: {e}")
+
+    def get_optimal_capture_options(self, codec: str = 'h264') -> Dict[str, str]:
+        """
+        Get optimal FFmpeg capture options for the given codec.
+
+        Args:
+            codec: Video codec (h264, h265, etc.)
+
+        Returns:
+            Dictionary of FFmpeg options
+        """
+        options = {
+            'rtsp_transport': 'tcp',
+            'buffer_size': '1024k',
+            'max_delay': '500000',  # 500ms
+            'fflags': '+genpts',
+            'flags': '+low_delay',
+            'probesize': '32',
+            'analyzeduration': '0'
+        }
+
+        # Add hardware acceleration if available
+        if self.nvidia_support:
+            # Force enable CUDA hardware acceleration for H.264 if CUDA is available
+            if codec == 'h264':
+                options.update({
+                    'hwaccel': 'cuda',
+                    'hwaccel_device': '0'
+                })
+                logger.info("Using NVIDIA NVDEC hardware acceleration for H.264")
+            elif codec == 'h265':
+                options.update({
+                    'hwaccel': 'cuda',
+                    'hwaccel_device': '0',
+                    'video_codec': 'hevc_cuvid',
+                    'hwaccel_output_format': 'cuda'
+                })
+                logger.info("Using NVIDIA CUVID hardware acceleration for H.265")
+
+        elif self.vaapi_support:
+            if codec == 'h264':
+                options.update({
+                    'hwaccel': 'vaapi',
+                    'hwaccel_device': '/dev/dri/renderD128',
+                    'video_codec': 'h264_vaapi'
+                })
+                logger.debug("Using VAAPI hardware acceleration")
+
+        return options
+
+    def format_opencv_options(self, options: Dict[str, str]) -> str:
+        """
+        Format options for OpenCV FFmpeg backend.
+
+        Args:
+            options: Dictionary of FFmpeg options
+
+        Returns:
+            Formatted options string for OpenCV
+        """
+        return '|'.join(f"{key};{value}" for key, value in options.items())
+
+    def get_hardware_encoder_options(self, codec: str = 'h264', quality: str = 'fast') -> Dict[str, str]:
+        """
+        Get optimal hardware encoding options.
+
+        Args:
+            codec: Video codec for encoding
+            quality: Quality preset (fast, medium, slow)
+
+        Returns:
+            Dictionary of encoding options
+        """
+        options = {}
+
+        if self.nvidia_support:
+            if codec == 'h264':
+                options.update({
+                    'video_codec': 'h264_nvenc',
+                    'preset': quality,
+                    'tune': 'zerolatency',
+                    'gpu': '0',
+                    'rc': 'cbr_hq',
+                    'surfaces': '64'
+                })
+            elif codec == 'h265':
+                options.update({
+                    'video_codec': 'hevc_nvenc',
+                    'preset': quality,
+                    'tune': 'zerolatency',
+                    'gpu': '0'
+                })
+
+        elif self.vaapi_support:
+            if codec == 'h264':
+                options.update({
+                    'video_codec': 'h264_vaapi',
+                    'vaapi_device': '/dev/dri/renderD128'
+                })
+
+        return options
+
+
+# Global instance
+_ffmpeg_caps = None
+
+def get_ffmpeg_capabilities() -> FFmpegCapabilities:
+    """Get or create the global FFmpeg capabilities instance."""
+    global _ffmpeg_caps
+    if _ffmpeg_caps is None:
+        _ffmpeg_caps = FFmpegCapabilities()
+    return _ffmpeg_caps
+
+def get_optimal_rtsp_options(rtsp_url: str) -> str:
+    """
+    Get optimal OpenCV FFmpeg options for RTSP streaming.
+
+    Args:
+        rtsp_url: RTSP stream URL
+
+    Returns:
+        Formatted options string for cv2.VideoCapture
+    """
+    caps = get_ffmpeg_capabilities()
+
+    # Detect codec from URL or assume H.264
+    codec = 'h265' if any(x in rtsp_url.lower() for x in ['h265', 'hevc']) else 'h264'
+
+    options = caps.get_optimal_capture_options(codec)
+    return caps.format_opencv_options(options)
\ No newline at end of file
diff --git a/core/utils/hardware_encoder.py b/core/utils/hardware_encoder.py
new file mode 100644
index 0000000..45bbb35
--- /dev/null
+++ b/core/utils/hardware_encoder.py
@@ -0,0 +1,173 @@
+"""
+Hardware-accelerated image encoding using NVIDIA NVENC or Intel QuickSync
+"""
+
+import cv2
+import numpy as np
+import logging
+from typing import Optional, Tuple
+import os
+
+logger = logging.getLogger("detector_worker")
+
+
+class HardwareEncoder:
+    """Hardware-accelerated JPEG encoder using GPU."""
+
+    def __init__(self):
+        """Initialize hardware encoder."""
+        self.nvenc_available = False
+        self.vaapi_available = False
+        self.turbojpeg_available = False
+
+        # Check for TurboJPEG (fastest CPU-based option)
+        try:
+            from turbojpeg import TurboJPEG
+            self.turbojpeg = TurboJPEG()
+            self.turbojpeg_available = True
+            logger.info("TurboJPEG accelerated encoding available")
+        except ImportError:
+            logger.debug("TurboJPEG not available")
+
+        # Check for NVIDIA NVENC support
+        try:
+            # Test if we can create an NVENC encoder
+            test_frame = np.zeros((720, 1280, 3), dtype=np.uint8)
+            fourcc = cv2.VideoWriter_fourcc(*'H264')
+            test_writer = cv2.VideoWriter(
+                "test.mp4",
+                fourcc,
+                30,
+                (1280, 720),
+                [cv2.CAP_PROP_HW_ACCELERATION, cv2.VIDEO_ACCELERATION_ANY]
+            )
+            if test_writer.isOpened():
+                self.nvenc_available = True
+                logger.info("NVENC hardware encoding available")
+            test_writer.release()
+            if os.path.exists("test.mp4"):
+                os.remove("test.mp4")
+        except Exception as e:
+            logger.debug(f"NVENC not available: {e}")
+
+    def encode_jpeg(self, frame: np.ndarray, quality: int = 85) -> Optional[bytes]:
+        """
+        Encode frame to JPEG using the fastest available method.
+
+        Args:
+            frame: BGR image frame
+            quality: JPEG quality (1-100)
+
+        Returns:
+            Encoded JPEG bytes or None on failure
+        """
+        try:
+            # Method 1: TurboJPEG (3-5x faster than cv2.imencode)
+            if self.turbojpeg_available:
+                # Convert BGR to RGB for TurboJPEG
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                encoded = self.turbojpeg.encode(rgb_frame, quality=quality)
+                return encoded
+
+            # Method 2: Hardware-accelerated encoding via GStreamer (if available)
+            if self.nvenc_available:
+                return self._encode_with_nvenc(frame, quality)
+
+            # Fallback: Standard OpenCV encoding
+            encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
+            success, encoded = cv2.imencode('.jpg', frame, encode_params)
+            if success:
+                return encoded.tobytes()
+
+            return None
+
+        except Exception as e:
+            logger.error(f"Failed to encode frame: {e}")
+            return None
+
+    def _encode_with_nvenc(self, frame: np.ndarray, quality: int) -> Optional[bytes]:
+        """
+        Encode using NVIDIA NVENC hardware encoder.
+
+        This is complex to implement directly, so we'll use a GStreamer pipeline
+        if available.
+        """
+        try:
+            # Create a GStreamer pipeline for hardware encoding
+            height, width = frame.shape[:2]
+            gst_pipeline = (
+                f"appsrc ! "
+                f"video/x-raw,format=BGR,width={width},height={height},framerate=30/1 ! "
+                f"videoconvert ! "
+                f"nvvideoconvert ! "  # GPU color conversion
+                f"nvjpegenc quality={quality} ! "  # Hardware JPEG encoder
+                f"appsink"
+            )
+
+            # This would require GStreamer Python bindings
+            # For now, fall back to TurboJPEG or standard encoding
+            logger.debug("NVENC JPEG encoding not fully implemented, using fallback")
+            encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
+            success, encoded = cv2.imencode('.jpg', frame, encode_params)
+            if success:
+                return encoded.tobytes()
+
+            return None
+
+        except Exception as e:
+            logger.error(f"NVENC encoding failed: {e}")
+            return None
+
+    def encode_batch(self, frames: list, quality: int = 85) -> list:
+        """
+        Batch encode multiple frames for better GPU utilization.
+
+        Args:
+            frames: List of BGR frames
+            quality: JPEG quality
+
+        Returns:
+            List of encoded JPEG bytes
+        """
+        encoded_frames = []
+
+        if self.turbojpeg_available:
+            # TurboJPEG can handle batch encoding efficiently
+            for frame in frames:
+                rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                encoded = self.turbojpeg.encode(rgb_frame, quality=quality)
+                encoded_frames.append(encoded)
+        else:
+            # Fallback to sequential encoding
+            for frame in frames:
+                encoded = self.encode_jpeg(frame, quality)
+                encoded_frames.append(encoded)
+
+        return encoded_frames
+
+
+# Global encoder instance
+_hardware_encoder = None
+
+
+def get_hardware_encoder() -> HardwareEncoder:
+    """Get or create the global hardware encoder instance."""
+    global _hardware_encoder
+    if _hardware_encoder is None:
+        _hardware_encoder = HardwareEncoder()
+    return _hardware_encoder
+
+
+def encode_frame_hardware(frame: np.ndarray, quality: int = 85) -> Optional[bytes]:
+    """
+    Convenience function to encode a frame using hardware acceleration.
+
+    Args:
+        frame: BGR image frame
+        quality: JPEG quality (1-100)
+
+    Returns:
+        Encoded JPEG bytes or None on failure
+    """
+    encoder = get_hardware_encoder()
+    return encoder.encode_jpeg(frame, quality)
\ No newline at end of file
diff --git a/requirements.base.txt b/requirements.base.txt
index 04e90ba..b8af923 100644
--- a/requirements.base.txt
+++ b/requirements.base.txt
@@ -6,4 +6,7 @@ scipy
 filterpy
 psycopg2-binary
 lap>=0.5.12
-pynvml
\ No newline at end of file
+pynvml
+PyTurboJPEG
+PyNvVideoCodec
+cupy-cuda12x
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 034d18e..2afeb0e 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,4 +5,5 @@ fastapi[standard]
 redis
 urllib3<2.0.0
 numpy
-requests
\ No newline at end of file
+requests
+watchdog
\ No newline at end of file