diff --git a/.gitignore b/.gitignore
index 0ef98c3..e2a5a23 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,3 +10,6 @@ out/
 bin/
 obj/
 .vscode/
+.appdata/
+AppData/
+
diff --git a/Backend Architecture & Integration_Guide.md b/Backend Architecture & Integration_Guide.md
new file mode 100644
index 0000000..8365b5a
--- /dev/null
+++ b/Backend Architecture & Integration_Guide.md	
@@ -0,0 +1,1225 @@
+# Backend Architecture and Integration Guide
+
+## 1. Core Entities
+
+### 1.1 Helper
+
+Volunteer responder capable of assisting users.
+
+`Response`
+
+```json
+[
+
+
+{
+  "id": "helper_101",
+  "name": "Rahul Kumar",
+  "phone": "+91XXXXXXXXXX",
+  "skills": ["cpr", "first_aid"],
+  "location": {
+    "lat": 23.796,
+    "lng": 86.432
+  },
+  "distance": "5km",
+  "status": "available",
+  "rating": 4.7,
+  "verified": true
+}
+
+{
+  "id": "helper_102",
+  "name": "Priya Singh",
+  "phone": "+91XXXXXXXXXX",
+  "skills": ["first_aid"],
+  "location": {
+    "lat": 23.798,
+    "lng": 86.435
+  },
+  "distance": "3km",
+  "status": "available",
+  "rating": 4.9,
+  "verified": true
+}
+
+
+]
+
+```
+
+Future fields may include:
+
+- vehicle availability
+- certifications
+- active assignments
+- response speed metrics
+
+---
+
+### 1.2 NGO / Organization
+
+Organizations that provide structured emergency assistance.
+
+`Response`
+
+```json
+[
+  {
+    "id": "ngo_001",
+    "name": "Red Cross Dhanbad",
+    "phone": "+91XXXXXXXXXX",
+    "services": ["medical", "disaster_relief"],
+    "location": {
+      "lat": 23.8,
+      "lng": 86.45
+    },
+    "distance": "1km",
+    "coverageRadius": 50,
+    "activeResponders": 8
+  },
+
+  {
+    "id": "ngo_002",
+    "name": "Dhanbad Fire Department",
+    "phone": "+91XXXXXXXXXX",
+    "services": ["medical", "disaster_relief"],
+    "location": {
+      "lat": 23.8,
+      "lng": 86.45
+    },
+    "distance": "500m",
+    "coverageRadius": 50,
+    "activeResponders": 8
+  }
+  // ....
+]
+```
+
+Future fields:
+
+- response vehicles
+- operating hours
+- dispatch teams
+- emergency capacity
+
+### 1.3 AI Emergency System
+
+**Method**
+
+```text
+POST
+```
+
+**URL**
+
+```text
+{{baseUrl}}/api/chatWithAi
+```
+
+The AI system checks the user's problem and decides what to do next.
+
+It reads the user's:
+
+- message
+- voice
+- location
+- conversation
+
+Then the AI decides whether the situation is **small** or **dangerous**.
+
+#### AI Decision Flow
+
+```text
+AI checks the problem
+       ↓
+Small problem -> show guidance tips
+       ↓
+Big danger -> notify nearby helpers
+       ↓
+Alert family + helpers
+       ↓
+Voice instructions for user
+       ↓
+Help arrives in 2-5 minutes
+```
+
+---
+
+#### Small Problem (Guidance Mode)
+
+If the AI thinks the situation is **not very dangerous**, it gives simple guidance.
+
+Examples:
+
+```text
+Apply pressure to stop bleeding
+Wash the wound with clean water
+Stay calm and sit down
+```
+
+No SOS alert is sent in this case.
+
+---
+
+#### Big Danger (Emergency Mode)
+
+If the AI detects a **serious emergency**, it will automatically trigger an SOS alert.
+
+Examples of serious emergencies:
+
+```text
+heart attack
+person unconscious
+heavy bleeding
+fire
+major accident
+```
+
+The AI will:
+
+- send SOS to the server
+- notify nearby helpers
+- alert family members
+- start voice guidance
+
+---
+
+#### AI Triggering SOS
+
+When the AI detects a dangerous situation, it sends the emergency data to the backend.
+
+**Method**
+
+```text
+POST
+```
+
+**URL**
+
+```text
+{{baseUrl}}/api/emergency/sos
+```
+
+**Authorization**
+
+```text
+Bearer Token ({{accessToken}})
+```
+
+Request body example:
+
+```json
+{
+  "title": "Medical Emergency",
+  "message": "Severe chest pain",
+  "latitude": 40.7128,
+  "longitude": -74.006,
+  "address": "123 Main St, New York, NY",
+  "medicalInfo": {
+    "bloodType": "O+",
+    "conditions": ["Asthma"]
+    // ...additional medical info
+  }
+}
+```
+
+---
+
+#### Voice Guidance for User
+
+While help is coming, the AI gives instructions.
+
+Examples:
+
+```text
+Stay calm. Help is on the way.
+Check if the person is breathing.
+Apply pressure to the wound.
+Move away from smoke.
+```
+
+This helps users handle the situation until responders arrive.
+
+### 1.4 AI Emergency Creation
+
+Once the AI finishes checking the situation in **1.4**, it decides whether the problem is serious enough to create an emergency.
+
+If the AI detects **big danger**, it creates an **Emergency record** using important fields from the emergency schema.
+
+The AI collects the following information:
+
+- emergency type (medical, accident, fire, etc.)
+- priority level (critical, high, medium)
+- user location
+- user information
+- description of the problem
+- medical information if available
+
+Then the AI sends this data to the emergency API.
+
+---
+
+#### AI Emergency Creation Flow
+
+```text
+AI analyzes user message / voice
+        ↓
+AI detects serious danger
+        ↓
+Collect emergency data
+        ↓
+Create emergency request
+        ↓
+Send data to Emergency API
+        ↓
+Emergency stored in database
+        ↓
+Helper matching system starts
+```
+
+---
+
+#### Emergency API
+
+**Method**
+
+```
+POST
+```
+
+**URL**
+
+```
+{{baseUrl}}/api/emergency/sos
+```
+
+**Authorization**
+
+```
+Bearer Token ({{accessToken}})
+```
+
+---
+
+#### Example Request Sent by AI
+
+```json
+{
+  "type": "medical",
+  "priority": "critical",
+  "title": "Medical Emergency",
+  "description": "Severe chest pain and breathing difficulty",
+
+  "location": {
+    "type": "Point",
+    "coordinates": [-74.006, 40.7128],
+    "address": "123 Main St, New York, NY",
+    "accuracy": 15
+  },
+
+  "medicalInfo": {
+    "bloodType": "O+",
+    "conditions": ["Asthma"]
+  }
+}
+```
+
+## What Happens After Emergency is Created
+
+Once the emergency is stored:
+
+1. The system saves the emergency in the database.
+2. Emergency status becomes **active**.
+3. The system sends the emergency data to the **dispatch engine**.
+4. The dispatch engine uses **AI analysis from section 1.4** to determine what type of helpers are required.
+
+Example AI result:
+
+```json
+{
+  "requiredHelpers": ["doctor", "nurse", "ambulance"]
+}
+```
+
+or
+
+```json
+{
+  "requiredHelpers": ["firefighter", "rescue_team", "ngo"]
+}
+```
+
+5. Based on the required helper types, the system searches for **nearby helpers or NGOs whose skills match the emergency**.
+
+Example matching logic:
+
+- medical emergency → doctor, nurse, ambulance
+- fire emergency → firefighter, rescue team
+- accident → first aid helper, ambulance
+- disaster → NGO + rescue team
+
+6. The system finds helpers within the **search radius** using the location data.
+
+7. All matching helpers are **notified in real time** using WebSocket / Push notifications.
+
+Example real-time notification event:
+
+```
+event: emergency_alert
+data:
+{
+  "emergencyId": "65e5b4f2c9e77c001f3e45b2",
+  "type": "medical",
+  "priority": "critical",
+  "distance": "1.2km"
+}
+```
+
+8. Helpers receive the emergency request in their app and can **accept or reject** it.
+
+9. Once a helper accepts the request, their status changes through the response stages.
+
+```
+requested → accepted → arriving → arrived
+```
+
+10. Response metrics start tracking the event.
+
+Example metrics started:
+
+```
+sosTriggeredAt
+firstHelperAssignedAt
+firstHelperAcceptedAt
+firstHelperArrivedAt
+```
+
+These metrics help measure **response time and system performance**.
+
+---
+
+## Communication Log
+
+Each important event is stored in the communication log.
+
+Examples:
+
+```
+SOS sent
+Helpers notified
+Helper accepted
+Helper arrived
+Status updated
+```
+
+This allows the system to track the **complete emergency timeline**.
+
+---
+
+## Final Result
+
+After the emergency is created:
+
+- AI determines the **required helper types**
+- nearby helpers or NGOs with matching skills are found
+- helpers are **notified in real time**
+- the first available helper accepts the request
+- the AI continues giving voice instructions
+- help arrives as quickly as possible
+
+Goal response time:
+
+```
+2–5 minutes
+```
+
+---
+
+Your sections are already strong. I improved them **slightly for clarity, consistency, and flow**, while keeping your structure almost the same. Improvements include:
+
+- clearer flow
+- small grammar fixes
+- better SMS formatting
+- better separation between **Family Alert** and **Status Updates**
+- more consistent wording with backend systems
+- added **Google Maps link improvement**
+- clarified **real-time updates**
+
+Below is the **improved version**.
+
+---
+
+# 1.5 Family Alert System
+
+When an emergency is created in **1.4 AI Emergency Creation**, the system also notifies the user's **registered family members or emergency contacts**.
+
+The system fetches the emergency details created in **Section 1.4** and sends them to all registered family numbers using SMS.
+
+This ensures that family members are aware of the situation immediately and can monitor updates while help is on the way.
+
+---
+
+## Family Alert Flow
+
+```
+Emergency created (Section 1.4)
+        ↓
+Fetch emergency data
+        ↓
+Fetch user's emergency contacts
+        ↓
+Generate emergency SMS message
+        ↓
+Send SMS to all family numbers
+        ↓
+Family receives emergency alert
+```
+
+---
+
+## Data Used from Section 1.4
+
+The SMS message is generated using the emergency data created earlier.
+
+Important fields used:
+
+- `title`
+- `description`
+- `type`
+- `location.address`
+- `location.coordinates`
+- `priority`
+- `createdAt`
+
+Example emergency data:
+
+```json
+{
+  "type": "medical",
+  "priority": "critical",
+  "title": "Medical Emergency",
+  "description": "Severe chest pain and breathing difficulty",
+  "location": {
+    "coordinates": [-74.006, 40.7128],
+    "address": "123 Main St, New York, NY"
+  }
+}
+```
+
+---
+
+## Example SMS Message
+
+```
+🚨 LifeLine Emergency Alert
+
+An SOS has been triggered.
+
+Emergency: Medical Emergency
+Details: Severe chest pain and breathing difficulty
+Priority: CRITICAL
+
+Location:
+123 Main St, New York, NY
+
+View Location:
+https://maps.google.com/?q=40.7128,-74.006
+
+Help is on the way.
+
+Track live location:
+https://lifeline.app/track/abc123
+```
+
+---
+
+## Fast2SMS Integration
+
+The backend uses **Fast2SMS** to send the alert message.
+
+Example implementation:
+
+```javascript
+const options = {
+  method: 'POST',
+  url: 'https://www.fast2sms.com/dev/bulkV2',
+  headers: {
+    accept: 'application/json',
+    authorization: process.env.FAST2SMS_API_KEY,
+    'content-type': 'application/json',
+  },
+  data: {
+    route: 'q',
+    numbers: mobileNumbers,
+    message: `🚨 LifeLine Emergency Alert
+
+Emergency: ${title}
+Details: ${description}
+Priority: ${priority}
+
+Location:
+${address}
+
+View Map:
+https://maps.google.com/?q=${latitude},${longitude}
+
+Help is on the way.`,
+  },
+};
+```
+
+---
+
+## Purpose
+
+The family alert system ensures that:
+
+- family members are notified immediately
+- they receive the **exact emergency details**
+- they know the **user's location**
+- they can **track the situation in real time**
+
+This allows family members to stay informed while helpers are responding to the emergency.
+
+---
+
+# 1.6 Helper & NGO Status Updates
+
+After helpers or NGOs are notified about an emergency, the system continuously sends **status updates** to the user and the user's emergency contacts.
+
+These updates allow everyone involved to understand what is happening and when help will arrive.
+
+Status updates can be delivered through:
+
+- in-app notifications
+- push notifications
+- SMS alerts (for critical updates)
+
+---
+
+## Status Update Flow
+
+```
+Emergency created
+        ↓
+Helpers / NGOs notified
+        ↓
+Helper accepts request
+        ↓
+Status updates sent to user
+        ↓
+Status updates sent to family contacts
+        ↓
+Helper arrives at location
+        ↓
+Emergency resolved
+```
+
+---
+
+## Helper Status Stages
+
+Each helper request moves through different stages.
+
+```
+requested → accepted → arriving → arrived → completed
+```
+
+Explanation:
+
+| Status    | Meaning                             |
+| --------- | ----------------------------------- |
+| requested | helper received emergency request   |
+| accepted  | helper accepted the request         |
+| arriving  | helper is traveling to the location |
+| arrived   | helper reached the user             |
+| completed | emergency resolved                  |
+
+---
+
+## Example Status Update (Helper Accepted)
+
+```
+LifeLine Update
+
+A helper has accepted the emergency request.
+
+Helper: Rahul Kumar
+Skill: CPR / First Aid
+Distance: 1.2 km
+Estimated arrival: 3 minutes
+```
+
+---
+
+## Example Status Update (Helper Arriving)
+
+```
+LifeLine Update
+
+Helper Rahul Kumar is on the way.
+
+Current distance: 800 meters
+Estimated arrival: 2 minutes
+```
+
+---
+
+## Example Status Update (Helper Arrived)
+
+```
+LifeLine Update
+
+Your helper has arrived at the location.
+
+Helper: Rahul Kumar
+Status: Arrived
+```
+
+---
+
+## NGO Status Updates
+
+If the emergency requires an NGO or organization, the system also sends updates about the NGO response.
+
+Example:
+
+```
+LifeLine Update
+
+Red Cross Dhanbad has responded to the emergency.
+
+Rescue team dispatched.
+Estimated arrival: 5 minutes
+```
+
+---
+
+## Notification Recipients
+
+Status updates are sent to:
+
+- the **user who triggered the SOS**
+- the **registered emergency contacts**
+- optionally **admins or dispatch operators**
+
+---
+
+## Real-Time Updates
+
+To deliver updates quickly, the system uses real-time communication.
+
+Recommended technologies:
+
+- **WebSocket (Socket.io)** for live updates
+- **Push notifications** for mobile alerts
+- **SMS** for emergency contacts
+
+---
+
+## Example Real-Time Event
+
+```json
+{
+  "event": "helper_status_update",
+  "emergencyId": "65e5b4f2c9e77c001f3e45b2",
+  "helperName": "Rahul Kumar",
+  "status": "arriving",
+  "distance": "800m",
+  "estimatedArrival": "2 minutes"
+}
+```
+
+# 1.7 Smart Helper Ranking System
+
+When an emergency occurs, there may be **many helpers available nearby**.
+Sending alerts to all helpers at once can create confusion and inefficient responses.
+
+To solve this, the system uses a **Smart Helper Ranking System** to identify the **best possible responders**.
+
+This ranking system evaluates helpers using multiple factors instead of only distance.
+
+---
+
+## Ranking Factors
+
+The system calculates a **helper score** based on the following parameters:
+
+| Factor         | Description                                       |
+| -------------- | ------------------------------------------------- |
+| Distance       | How far the helper is from the emergency location |
+| Rating         | Helper rating based on previous responses         |
+| Response Speed | Average time taken to accept emergencies          |
+| Availability   | Whether the helper is currently available         |
+| Experience     | Number of emergencies handled before              |
+| Verification   | Whether the helper is identity verified           |
+
+---
+
+## Helper Score Calculation
+
+Each helper receives a **score** calculated by the dispatch engine.
+
+Example formula:
+
+```
+helperScore =
+(distanceWeight × distanceScore)
++ (ratingWeight × ratingScore)
++ (responseSpeedWeight × responseSpeedScore)
++ (experienceWeight × experienceScore)
++ (availabilityWeight × availabilityScore)
+```
+
+Higher scores indicate **better responders**.
+
+---
+
+## Example Helper Ranking
+
+Example evaluated helpers:
+
+```json
+[
+  {
+    "helperId": "helper_101",
+    "distance": "1.2km",
+    "rating": 4.8,
+    "avgResponseTime": "2.3 minutes",
+    "completedEmergencies": 54,
+    "score": 92
+  },
+  {
+    "helperId": "helper_102",
+    "distance": "2.1km",
+    "rating": 4.9,
+    "avgResponseTime": "3.0 minutes",
+    "completedEmergencies": 33,
+    "score": 88
+  }
+]
+```
+
+The dispatch engine selects the **top-ranked helpers first**.
+
+---
+
+## Benefits
+
+This system improves:
+
+- emergency response reliability
+- faster helper arrival
+- higher quality assistance
+- better system performance
+
+---
+
+# 1.8 Multi-Stage Dispatch System
+
+Not every emergency requires **all helpers to be notified at once**.
+
+Instead, the system uses a **wave-based dispatch model**.
+
+This reduces notification overload and improves response efficiency.
+
+---
+
+## Dispatch Waves
+
+The dispatch system sends alerts in **multiple stages**.
+
+```
+Wave 1 → Top helpers within 1 km
+Wave 2 → Additional helpers within 3 km
+Wave 3 → NGOs and emergency organizations
+```
+
+---
+
+## Dispatch Flow
+
+```
+Emergency created
+        ↓
+Helper ranking system selects best responders
+        ↓
+Wave 1 notifications sent
+        ↓
+Wait for response (10 seconds)
+        ↓
+If no helper accepts
+        ↓
+Wave 2 notifications sent
+        ↓
+If still no response
+        ↓
+Wave 3 escalation to NGOs and organizations
+```
+
+---
+
+## Example Dispatch Notification
+
+```json
+{
+  "event": "emergency_alert",
+  "wave": 1,
+  "emergencyId": "65e5b4f2c9e77c001f3e45b2",
+  "priority": "critical",
+  "distance": "1.2km"
+}
+```
+
+---
+
+## Advantages
+
+Wave-based dispatch:
+
+- prevents responder crowding
+- prioritizes best helpers
+- ensures emergency coverage
+
+---
+
+# 1.9 Live Location Tracking
+
+During emergencies, the user's location may **change frequently**.
+
+For example:
+
+- accident victim moving
+- fire evacuation
+- helper approaching location
+
+To support this, the system uses **live location tracking**.
+
+---
+
+## Location Update System
+
+When SOS is active, the mobile app sends **location updates** about every 5 seconds.
+
+Current mobile implementation:
+
+- if app is open, foreground GPS tracking runs
+- if app is in background, background tracking runs
+- only one tracking mode runs at a time
+
+Before sending data to backend, the app cleans the location data:
+
+- drops invalid or very old points
+- waits at least about 4.5 seconds between sends
+- ignores tiny GPS shake when user is not moving
+- smooths small random drift
+- if no good point is sent for about 15 seconds, sends one keepalive update
+
+---
+
+## Location Update Flow
+
+```
+Emergency triggered
+        ↓
+Mobile SOS tracking starts
+        ↓
+App chooses foreground or background mode
+        ↓
+App checks point quality
+        ↓
+`location:update` sent to server
+        ↓
+Server saves location and broadcasts it
+        ↓
+Helpers receive live updates
+```
+
+---
+
+## Example Location Update Event
+
+```json
+{
+  "event": "location:update",
+  "userId": "65e5b4f2c9e77c001f3e45b2",
+  "role": "user",
+  "latitude": 23.796,
+  "longitude": 86.432,
+  "accuracy": 8,
+  "timestamp": "2026-03-08T12:05:21Z"
+}
+```
+
+---
+
+## Benefits
+
+Live tracking allows helpers to:
+
+- locate users faster
+- adjust routes in real time
+- navigate moving victims
+- see cleaner map movement with less false GPS drift
+
+---
+
+# 1.10 Emergency Severity Scoring
+
+Not all emergencies are equally dangerous.
+
+To improve decision making, the AI system calculates a **severity score**.
+
+---
+
+## Severity Score Range
+
+```
+0 → No danger
+100 → Extreme emergency
+```
+
+---
+
+## Example Severity Scores
+
+| Situation       | Score |
+| --------------- | ----- |
+| Minor injury    | 20    |
+| Broken bone     | 60    |
+| Severe bleeding | 85    |
+| Heart attack    | 95    |
+| Fire incident   | 90    |
+
+---
+
+## AI Evaluation Inputs
+
+The AI evaluates:
+
+- text message from user
+- voice input
+- breathing sounds
+- panic detection
+- previous medical conditions
+- environmental clues
+
+---
+
+## Example AI Result
+
+```json
+{
+  "emergencyType": "medical",
+  "severityScore": 91,
+  "priority": "critical"
+}
+```
+
+---
+
+## Severity-Based Actions
+
+| Score Range | Action                          |
+| ----------- | ------------------------------- |
+| 0–30        | Guidance only                   |
+| 31–70       | Notify nearby helpers           |
+| 71–100      | Trigger full emergency response |
+
+---
+
+# 1.11 Emergency Escalation System
+
+Sometimes nearby helpers **do not accept the emergency request**.
+
+To ensure assistance is always available, the system uses an **automatic escalation mechanism**.
+
+---
+
+## Escalation Flow
+
+```
+Emergency created
+        ↓
+Notify nearby helpers
+        ↓
+Wait for acceptance (20 seconds)
+        ↓
+If no response
+        ↓
+Expand search radius
+        ↓
+Notify additional helpers
+        ↓
+Alert NGOs and emergency services
+```
+
+---
+
+## Escalation Levels
+
+| Level   | Action                                  |
+| ------- | --------------------------------------- |
+| Level 1 | Notify helpers within 1 km              |
+| Level 2 | Notify helpers within 5 km              |
+| Level 3 | Notify NGOs and emergency organizations |
+
+---
+
+## Escalation Event Example
+
+```json
+{
+  "event": "dispatch_escalation",
+  "level": 2,
+  "searchRadius": "5km",
+  "emergencyId": "65e5b4f2c9e77c001f3e45b2"
+}
+```
+
+---
+
+# 1.12 Hospital Integration
+
+Hospitals play a crucial role in emergency response.
+
+The system integrates nearby hospitals to coordinate medical support.
+
+---
+
+## Hospital Entity
+
+Example hospital data:
+
+```json
+{
+  "id": "hospital_001",
+  "name": "City Medical Center",
+  "location": {
+    "lat": 23.80,
+    "lng": 86.45
+  },
+  "emergencyBeds": 12,
+  "ambulances": 3,
+  "traumaCenter": true
+}
+```
+
+---
+
+## Hospital Integration Flow
+
+```
+Emergency detected
+        ↓
+AI identifies medical emergency
+        ↓
+Find nearest hospital
+        ↓
+Notify emergency department
+        ↓
+Prepare emergency team
+```
+
+---
+
+## Benefits
+
+Hospital integration enables:
+
+- faster treatment preparation
+- ambulance coordination
+- emergency bed availability
+
+---
+
+# 1.13 Offline Emergency Trigger (Optional)
+
+In many regions, internet connectivity may be unstable.
+
+The system supports **offline emergency triggers**.
+
+---
+
+## Offline SOS Methods
+
+Users can trigger SOS using:
+
+- power button pressed multiple times
+- special SMS message
+- offline emergency mode
+
+---
+
+## Example SMS SOS
+
+```
+SOS LAT:23.796 LNG:86.432
+```
+
+The backend server detects this message and creates an emergency event.
+
+---
+
+# 1.14 Emergency Timeline System
+
+Every emergency generates a **complete timeline of events**.
+
+This allows tracking of the entire emergency lifecycle.
+
+---
+
+## Example Timeline
+
+```
+12:01 SOS triggered
+12:01 AI analysis completed
+12:02 helpers notified
+12:03 helper accepted request
+12:05 helper arrived
+12:15 emergency resolved
+```
+
+---
+
+## Timeline Data Example
+
+```json
+{
+  "emergencyId": "65e5b4f2c9e77c001f3e45b2",
+  "events": [
+    { "type": "sos_triggered", "time": "12:01" },
+    { "type": "helper_notified", "time": "12:02" },
+    { "type": "helper_arrived", "time": "12:05" }
+  ]
+}
+```
+
+---
+
+# 1.15 System Analytics
+
+The platform tracks important metrics to improve system performance.
+
+---
+
+## Key Metrics
+
+| Metric                    | Purpose                       |
+| ------------------------- | ----------------------------- |
+| Average response time     | Measures system efficiency    |
+| Helper acceptance rate    | Measures responder engagement |
+| Emergency resolution rate | Measures success rate         |
+| AI detection accuracy     | Measures AI reliability       |
+
+---
+
+## Example Analytics Data
+
+```json
+{
+  "averageResponseTime": "2.7 minutes",
+  "helperAcceptanceRate": "74%",
+  "emergenciesResolved": 1250
+}
+```
diff --git a/LifeLine-Backend/.env.example b/LifeLine-Backend/.env.example
index 586aa6a..090bbce 100644
--- a/LifeLine-Backend/.env.example
+++ b/LifeLine-Backend/.env.example
@@ -6,6 +6,12 @@ JWT_SECRET=your_super_secret_key_here
 NODE_ENV=development
 FAST2SMS_API_KEY=your_fast2sms_api_key_here
 
+# Cloudinary (Profile Image Uploads)
+CLOUDINARY_CLOUD_NAME=your_cloud_name
+CLOUDINARY_API_KEY=your_api_key
+CLOUDINARY_API_SECRET=your_api_secret
+CLOUDINARY_PROFILE_FOLDER=lifeline/profile-pictures
+
 # AI Configuration (OpenAI / ChatGPT)
 OPENAI_API_KEY=your_openai_api_key_here
 OPENAI_MODEL=gpt-4o-mini
@@ -18,4 +24,4 @@ SESSION_TTL=300
 
 # Triage Settings
 MAX_TRIAGE_QUESTIONS=8
-TRIAGE_TIMEOUT_SECONDS=300
\ No newline at end of file
+TRIAGE_TIMEOUT_SECONDS=300
diff --git a/LifeLine-Backend/docker-compose.yml b/LifeLine-Backend/docker-compose.yml
index f886206..c238a3b 100644
--- a/LifeLine-Backend/docker-compose.yml
+++ b/LifeLine-Backend/docker-compose.yml
@@ -11,7 +11,26 @@ services:
       - /app/node_modules
     environment:
       - NODE_ENV=development
+      - MONGODB_URI=mongodb://mongo:27017/lifeline
     env_file:
       - .env
-    command: pnpm run dev:docker
+    depends_on:
+      - mongo
+    command: sh -c "pnpm run dev:docker & pnpm run share"
     restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "5"
+  mongo:
+    image: mongo:6
+    container_name: lifeline-mongo
+    ports:
+      - "27017:27017"
+    volumes:
+      - lifeline_mongo:/data/db
+    restart: unless-stopped
+
+volumes:
+  lifeline_mongo:
diff --git a/LifeLine-Backend/docs/04-Business-Logic-and-Rules.md b/LifeLine-Backend/docs/04-Business-Logic-and-Rules.md
index d334f14..eeaaa56 100644
--- a/LifeLine-Backend/docs/04-Business-Logic-and-Rules.md
+++ b/LifeLine-Backend/docs/04-Business-Logic-and-Rules.md
@@ -12,43 +12,43 @@ This document defines the core rules and constraints that govern the LifeLine sy
 
 ## 2. Emergency Lifecycle
 
-1.  **Creation:**
-    *   **Rule:** User must be authenticated (JWT) to trigger SOS.
-    *   **Rule:** Location coordinates are mandatory. *System attempts to fallback to user's last known location if missing in request.*
-    *   **Status:** Starts as `active`.
-
-2.  **Notification:**
-    *   **Rule:** System searches for Helpers within a defined radius (Default: 5km).
-    *   **Rule:** Helpers must be `ONLINE` and `VERIFIED` to receive alerts.
-
-3.  **Acceptance:**
-    *   **Rule:** Multiple helpers can accept an emergency request.
-    *   **Constraint:** Acceptance is allowed until `maxHelpers` limit (default: 3) is reached.
-    *   **Status:** Remains `active` but updates `assignedHelpers` status to `accepted`.
-    *   **Action:** Chat room is created; user notified of helper ETA.
-
-4.  **Resolution:**
-    *   **Rule:** Only the User or Helper can mark an emergency as `RESOLVED`.
-    *   **Status:** Changes to `resolved`.
-    *   **Action:** Chat is archived; session closed.
+1. **Creation:**
+    * **Rule:** User must be authenticated (JWT) to trigger SOS.
+    * **Rule:** Location coordinates are mandatory. *System attempts to fallback to user's last known location if missing in request.*
+    * **Status:** Starts as `active`.
+
+2. **Notification:**
+    * **Rule:** System searches for Helpers within a defined radius (Default: 5km).
+    * **Rule:** Helpers must be `ONLINE` and `VERIFIED` to receive alerts.
+
+3. **Acceptance:**
+    * **Rule:** Multiple helpers can accept an emergency request.
+    * **Constraint:** Acceptance is allowed until `maxHelpers` limit (default: 3) is reached.
+    * **Status:** Remains `active` but updates `assignedHelpers` status to `accepted`.
+    * **Action:** Chat room is created; user notified of helper ETA.
+
+4. **Resolution:**
+    * **Rule:** Only the User or Helper can mark an emergency as `RESOLVED`.
+    * **Status:** Changes to `resolved`.
+    * **Action:** Chat is archived; session closed.
 
 ## 3. AI Triage Logic
 
-*   **Trigger:** User initiates chat with "Triage Bot".
-*   **Process:** AI asks clarifying questions (Default max: 8).
-*   **Output:**
-    *   **Advice:** Immediate first-aid steps.
-    *   **Severity Score:** Low/Medium/High.
-    *   **Escalation:** If High severity, system auto-prompts to create an SOS.
+* **Trigger:** User initiates chat with "Triage Bot".
+* **Process:** AI asks clarifying questions (Default max: 8).
+* **Output:**
+  * **Advice:** Immediate first-aid steps.
+  * **Severity Score:** Low/Medium/High.
+  * **Escalation:** If High severity, system auto-prompts to create an SOS.
 
 ## 4. Helper Verification
 
-*   **Requirement:** Helpers must upload valid ID/Certification to be "Verified."
-*   **Constraint:** Unverified helpers cannot accept emergency requests.
-*   **Validation:** Admin manual review via `PATCH /:id/credentials/:credentialId/verify`.
+* **Requirement:** Helpers must upload valid ID/Certification to be "Verified."
+* **Constraint:** Unverified helpers cannot accept emergency requests.
+* **Validation:** Admin manual review via `PATCH /:id/credentials/:credentialId/verify`.
 
 ## 5. Data Privacy & Retention
 
-*   **Rule:** Emergency chats are accessible only to participants.
-*   **Retention:** Emergency logs are kept for legal compliance.
-*   **Location:** Real-time tracking is active *only* during an active emergency or when app is in foreground.
+* **Rule:** Emergency chats are accessible only to participants.
+* **Retention:** Emergency logs are kept for legal compliance.
+* **Location:** Real-time tracking runs only during active emergencies. If the app is open it tracks in foreground; if the app goes to background it continues with background tracking.
diff --git a/LifeLine-Backend/docs/11-Socket-Protocol.md b/LifeLine-Backend/docs/11-Socket-Protocol.md
index 29a8376..022c3d6 100644
--- a/LifeLine-Backend/docs/11-Socket-Protocol.md
+++ b/LifeLine-Backend/docs/11-Socket-Protocol.md
@@ -3,91 +3,109 @@
 This document outlines the real-time event-driven architecture using **Socket.io**.
 
 ## Connection
-*   **Endpoint:** `ws://localhost:5000`
-*   **Auth:** No handshake auth required. Client must emit `user:register` immediately after connection.
+
+* **Endpoint:** `ws://localhost:5000`
+* **Auth:** No handshake auth required. Client must emit `user:register` immediately after connection.
 
 ## Registration
-*   **Event:** `user:register`
-*   **Payload:** `{ userId: "..." }`
-*   **Description:** Maps the socket ID to a User ID for targeted notifications.
+
+* **Event:** `user:register`
+* **Payload:** `{ userId: "..." }`
+* **Description:** Maps the socket ID to a User ID for targeted notifications.
 
 ## Namespaces & Rooms
-*   `user:{userId}` - Private channel for specific user notifications.
-*   `emergency:{emergencyId}` - Shared room for all participants in an active emergency.
+
+* `user:{userId}` - Private channel for specific user notifications.
+* `emergency:{emergencyId}` - Shared room for all participants in an active emergency.
 
 ## Events
 
 ### 1. Emergency Lifecycle
 
 #### Client -> Server
-*   `emergency:triggerSOS`
-    *   **Payload:** `{ type, title, description, location: { coordinates, address... } }`
-    *   **Description:** User initiates a new emergency.
-*   `emergency:join`
-    *   **Payload:** `{ emergencyId, role }`
-    *   **Description:** User/Helper joins the active emergency room.
-*   `emergency:leave`
-    *   **Payload:** `{ emergencyId }`
-    *   **Description:** Participant leaves the room.
-*   `emergency:helperRespond`
-    *   **Payload:** `{ emergencyId, response: 'accepted'|'declined', eta, location }`
-    *   **Description:** Helper accepts or rejects the request.
-*   `emergency:helperArrived`
-    *   **Payload:** `{ emergencyId }`
-    *   **Description:** Helper confirms arrival at the scene.
+
+* `emergency:triggerSOS`
+  * **Payload:** `{ type, title, description, location: { coordinates, address... } }`
+  * **Description:** User initiates a new emergency.
+* `emergency:join`
+  * **Payload:** `{ emergencyId, role }`
+  * **Description:** User/Helper joins the active emergency room.
+* `emergency:leave`
+  * **Payload:** `{ emergencyId }`
+  * **Description:** Participant leaves the room.
+* `emergency:helperRespond`
+  * **Payload:** `{ emergencyId, response: 'accepted'|'declined', eta, location }`
+  * **Description:** Helper accepts or rejects the request.
+* `emergency:helperArrived`
+  * **Payload:** `{ emergencyId }`
+  * **Description:** Helper confirms arrival at the scene.
 
 #### Server -> Client
-*   `emergency:newAlert`
-    *   **Target:** Nearby Helpers
-    *   **Payload:** `{ emergencyId, location, distance, type, priority, timestamp }`
-*   `emergency:sosTriggered`
-    *   **Target:** User (Ack)
-    *   **Payload:** `{ success, emergencyId, assignedHelpers }`
-*   `emergency:participantJoined`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ emergencyId, userId, role, timestamp }`
-*   `emergency:participantLeft`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ emergencyId, userId, timestamp }`
-*   `emergency:helperResponse`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ emergencyId, helperId, response, eta, location }`
-*   `emergency:helperArrival`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ emergencyId, helperId, arrivedAt }`
-*   `emergency:status`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ status: 'resolved'|'cancelled', ...details }`
-*   `emergency:error`
-    *   **Target:** Sender
-    *   **Payload:** `{ success: false, message: "Error description" }`
+
+* `emergency:newAlert`
+  * **Target:** Nearby Helpers
+  * **Payload:** `{ emergencyId, location, distance, type, priority, timestamp }`
+* `emergency:sosTriggered`
+  * **Target:** User (Ack)
+  * **Payload:** `{ success, emergencyId, assignedHelpers }`
+* `emergency:participantJoined`
+  * **Target:** Emergency Room
+  * **Payload:** `{ emergencyId, userId, role, timestamp }`
+* `emergency:participantLeft`
+  * **Target:** Emergency Room
+  * **Payload:** `{ emergencyId, userId, timestamp }`
+* `emergency:helperResponse`
+  * **Target:** Emergency Room
+  * **Payload:** `{ emergencyId, helperId, response, eta, location }`
+* `emergency:helperArrival`
+  * **Target:** Emergency Room
+  * **Payload:** `{ emergencyId, helperId, arrivedAt }`
+* `emergency:status`
+  * **Target:** Emergency Room
+  * **Payload:** `{ status: 'resolved'|'cancelled', ...details }`
+* `emergency:error`
+  * **Target:** Sender
+  * **Payload:** `{ success: false, message: "Error description" }`
 
 ### 2. Chat & Communication
 
 #### Client -> Server
-*   `emergency:sendMessage`
-    *   **Payload:** `{ emergencyId, message, messageType: 'text' }`
+
+* `emergency:sendMessage`
+  * **Payload:** `{ emergencyId, message, messageType: 'text' }`
 
 #### Server -> Client
-*   `emergency:message`
-    *   **Payload:** `{ emergencyId, senderId, message, messageType, timestamp }`
+
+* `emergency:message`
+  * **Payload:** `{ emergencyId, senderId, message, messageType, timestamp }`
 
 ### 3. Location Tracking
 
 #### Client -> Server
-*   `location:update`
-    *   **Payload:** `{ latitude, longitude, accuracy, speed, heading, altitude }`
-    *   **Description:** Periodic update from User/Helper device.
+
+* `location:update`
+  * **Payload:** `{ latitude, longitude, accuracy?, speed?, heading?, altitude?, timestamp?, userId?, role? }`
+  * **Description:** Sent regularly during SOS (about every 5 seconds). Client filters noisy points before sending. Identity is mainly taken from `user:register`; `userId/role` here are optional.
 
 #### Server -> Client
-*   `emergency:locationUpdate`
-    *   **Target:** Emergency Room
-    *   **Payload:** `{ emergencyId, userId, location, timestamp }`
-    *   **Description:** Real-time map update for participants.
+
+* `location:updated`
+  * **Target:** Sender
+  * **Payload:** `{ success, message, data, source, timestamp, serverTimestamp }`
+  * **Description:** Confirms that the latest location was saved.
+* `emergency:locationUpdate`
+  * **Target:** `emergency:{emergencyId}`
+  * **Payload:** `{ emergencyId, userId, role, source, location, timestamp, serverTimestamp }`
+  * **Description:** Sends live map updates to everyone in that emergency room.
+* `location:userLocationUpdate`
+  * **Target:** `tracking:{userId}` subscribers
+  * **Payload:** `{ userId, role, source, location, timestamp, serverTimestamp }`
+  * **Description:** Sends live updates to users tracking that person.
 
 ### 4. Notifications
 
 #### Server -> Client
-*   `notification`
-    *   **Target:** `user:{userId}`
-    *   **Payload:** `{ type, title, message, data, timestamp }`
+
+* `notification`
+  * **Target:** `user:{userId}`
+  * **Payload:** `{ type, title, message, data, timestamp }`
diff --git a/LifeLine-Backend/docs/16-Backend-Features-Guide.md b/LifeLine-Backend/docs/16-Backend-Features-Guide.md
index e620cb4..24269c4 100644
--- a/LifeLine-Backend/docs/16-Backend-Features-Guide.md
+++ b/LifeLine-Backend/docs/16-Backend-Features-Guide.md
@@ -5,144 +5,171 @@ This document provides a comprehensive overview of the features implemented in t
 ---
 
 ## 1. Authentication & Identity
+
 **Goal**: Secure, stateless user management for Users, Helpers, and Organizations.
 
 ### Features
-*   **Multi-Role System**: Distinct profiles for `User` (Victim/General), `Helper` (Responder), and `NGO`.
-*   **JWT Authentication**: Stateless session management using JSON Web Tokens (Access + Refresh tokens).
-*   **Secure Password Handling**: Uses **Argon2** for industry-standard password hashing.
-*   **OTP Verification**: Phone/Email verification using 6-digit OTPs (via Fast2SMS/Email).
-*   **Rate Limiting**: Prevents brute-force attacks on login/signup endpoints.
+
+* **Multi-Role System**: Distinct profiles for `User` (Victim/General), `Helper` (Responder), and `NGO`.
+* **JWT Authentication**: Stateless session management using JSON Web Tokens (Access + Refresh tokens).
+* **Secure Password Handling**: Uses **Argon2** for industry-standard password hashing.
+* **OTP Verification**: Phone/Email verification using 6-digit OTPs (via Fast2SMS/Email).
+* **Rate Limiting**: Prevents brute-force attacks on login/signup endpoints.
 
 ### Implementation
-*   **Routes**: `/api/auth/v1/*`
-*   **Codebase**:
-    *   [Auth.controller.mjs](file:///src/api/Auth/v1/Auth.controller.mjs): Handles HTTP requests.
-    *   [Auth.service.mjs](file:///src/api/Auth/v1/Auth.service.mjs): Core business logic (hashing, token generation).
-    *   [Auth.middleware.mjs](file:///src/api/Auth/v1/Auth.middleware.mjs): Intercepts requests to verify `Authorization: Bearer <token>`.
+
+* **Routes**: `/api/auth/v1/*`
+* **Codebase**:
+  * [Auth.controller.mjs](file:///src/api/Auth/v1/Auth.controller.mjs): Handles HTTP requests.
+  * [Auth.service.mjs](file:///src/api/Auth/v1/Auth.service.mjs): Core business logic (hashing, token generation).
+  * [Auth.middleware.mjs](file:///src/api/Auth/v1/Auth.middleware.mjs): Intercepts requests to verify `Authorization: Bearer <token>`.
 
 ---
 
 ## 2. Emergency Response System (Core)
+
 **Goal**: Instant SOS triggering and lifecycle management of emergencies.
 
 ### Features
-*   **One-Tap SOS**: Creates an emergency record with location, type (Medical, Fire, etc.), and priority.
-*   **Real-time Tracking**: Live updates of Victim and Helper locations via WebSockets.
-*   **Emergency Lifecycle**: Tracks status transitions: `SEARCHING` -> `ASSIGNED` -> `ACTIVE` -> `RESOLVED`.
-*   **Nearby Helper Search**: Uses MongoDB Geospatial queries (`$near`, `$maxDistance`) to find responders within range.
+
+* **One-Tap SOS**: Creates an emergency record with location, type (Medical, Fire, etc.), and priority.
+* **Real-time Tracking**: Live updates of Victim and Helper locations via WebSockets.
+* **Emergency Lifecycle**: Tracks status transitions: `SEARCHING` -> `ASSIGNED` -> `ACTIVE` -> `RESOLVED`.
+* **Nearby Helper Search**: Uses MongoDB Geospatial queries (`$near`, `$maxDistance`) to find responders within range.
 
 ### Implementation
-*   **Routes**: `/api/emergency/*`
-*   **Codebase**:
-    *   [Emergency.service.mjs](file:///src/api/Emergency/Emergency.service.mjs): Manages emergency creation and status updates.
-    *   [socket/handlers/emergency.handler.mjs](file:///src/socket/handlers/emergency.handler.mjs): Handles real-time events like `SOS_TRIGGERED`, `HELPER_ACCEPTED`.
-    *   **Database**: Uses `2dsphere` indexes on `Location` schema for fast geospatial lookups.
+
+* **Routes**: `/api/emergency/*`
+* **Codebase**:
+  * [Emergency.service.mjs](file:///src/api/Emergency/Emergency.service.mjs): Manages emergency creation and status updates.
+  * [socket/handlers/emergency.handler.mjs](file:///src/socket/handlers/emergency.handler.mjs): Handles real-time events like `SOS_TRIGGERED`, `HELPER_ACCEPTED`.
+  * **Database**: Uses `2dsphere` indexes on `Location` schema for fast geospatial lookups.
 
 ---
 
 ## 3. AI Triage System
+
 **Goal**: AI-driven assessment to determine if a situation is a critical emergency.
 
 ### Features
-*   **Conversational Assessment**: Uses **OpenAI (GPT-4)** to ask clarifying questions about symptoms/situation.
-*   **Critical Fast-Track**: Regex-based detection of keywords (e.g., "unconscious", "fire", "bleeding") to trigger SOS immediately without waiting for AI.
-*   **Structured Output**: AI returns JSON decisions (`severity`, `action`, `category`) for programmatic handling.
-*   **Context Awareness**: Remembers previous messages in the session to provide coherent responses.
+
+* **Conversational Assessment**: Uses **OpenAI (GPT-4)** to ask clarifying questions about symptoms/situation.
+* **Critical Fast-Track**: Regex-based detection of keywords (e.g., "unconscious", "fire", "bleeding") to trigger SOS immediately without waiting for AI.
+* **Structured Output**: AI returns JSON decisions (`severity`, `action`, `category`) for programmatic handling.
+* **Context Awareness**: Remembers previous messages in the session to provide coherent responses.
 
 ### Implementation
-*   **Routes**: `/api/triage/*`
-*   **Codebase**:
-    *   [triageService.mjs](file:///src/Ai/triage/triageService.mjs): Orchestrates the LangChain flow.
-    *   [triagePrompts.mjs](file:///src/Ai/triage/triagePrompts.mjs): Contains system prompts and Few-Shot examples to guide the AI.
-    *   **State Management**: Uses **Redis** (or in-memory fallback) to store conversation history by `sessionId`.
+
+* **Routes**: `/api/triage/*`
+* **Codebase**:
+  * [triageService.mjs](file:///src/Ai/triage/triageService.mjs): Orchestrates the LangChain flow.
+  * [triagePrompts.mjs](file:///src/Ai/triage/triagePrompts.mjs): Contains system prompts and Few-Shot examples to guide the AI.
+  * **State Management**: Uses **Redis** (or in-memory fallback) to store conversation history by `sessionId`.
 
 ---
 
 ## 4. Medical Profile & Health Records
+
 **Goal**: Provide responders with critical health data during emergencies.
 
 ### Features
-*   **Comprehensive Health Data**: Stores Blood Type, Allergies, Chronic Conditions, Medications.
-*   **Emergency Access Control**: Data is encrypted but accessible to *verified* helpers only during an *active* SOS.
-*   **File Attachments**: Upload and retrieval of medical documents/reports.
+
+* **Comprehensive Health Data**: Stores Blood Type, Allergies, Chronic Conditions, Medications.
+* **Emergency Access Control**: Data is encrypted but accessible to *verified* helpers only during an *active* SOS.
+* **File Attachments**: Upload and retrieval of medical documents/reports.
 
 ### Implementation
-*   **Routes**: `/api/medical/v1/*`
-*   **Codebase**:
-    *   [Medical.Schema.mjs](file:///src/api/Medical/v1/Medical.Schema.mjs): Defines complex nested schemas for health data.
-    *   [Medical.controller.mjs](file:///src/api/Medical/Medical.controller.mjs): Handles CRUD operations and permission checks.
+
+* **Routes**: `/api/medical/v1/*`
+* **Codebase**:
+  * [Medical.Schema.mjs](file:///src/api/Medical/v1/Medical.Schema.mjs): Defines complex nested schemas for health data.
+  * [Medical.controller.mjs](file:///src/api/Medical/Medical.controller.mjs): Handles CRUD operations and permission checks.
 
 ---
 
 ## 5. Helper & Volunteer Ecosystem
+
 **Goal**: Manage the network of responders and their verification.
 
 ### Features
-*   **Skill Verification**: Helpers can list skills (CPR, First Aid) which are verified by admin/system.
-*   **Availability Toggle**: Helpers can go `Online`/`Offline` to control receiving SOS alerts.
-*   **Service Areas**: Defines the geographical radius where a helper operates.
-*   **Seamless Role Upgrade**: Standard users can upgrade to Helper status instantly by completing their profile.
+
+* **Skill Verification**: Helpers can list skills (CPR, First Aid) which are verified by admin/system.
+* **Availability Toggle**: Helpers can go `Online`/`Offline` to control receiving SOS alerts.
+* **Service Areas**: Defines the geographical radius where a helper operates.
+* **Seamless Role Upgrade**: Standard users can upgrade to Helper status instantly by completing their profile.
 
 ### Implementation
-*   **Routes**: `/api/helpers/v1/*`
-*   **Codebase**:
-    *   [Helper.model.mjs](file:///src/api/Helper/Helper.model.mjs): Schema for helper attributes, ratings, and verification status.
-    *   [Helper.service.mjs](file:///src/api/Helper/Helper.service.mjs): Logic for finding best-matched helpers based on skills and location.
+
+* **Routes**: `/api/helpers/v1/*`
+* **Codebase**:
+  * [Helper.model.mjs](file:///src/api/Helper/Helper.model.mjs): Schema for helper attributes, ratings, and verification status.
+  * [Helper.service.mjs](file:///src/api/Helper/Helper.service.mjs): Logic for finding best-matched helpers based on skills and location.
 
 ---
 
 ## 6. Real-Time Location Services
+
 **Goal**: continuous location tracking and geofencing.
 
 ### Features
-*   **Live Location Stream**: High-frequency location updates via WebSocket during active emergencies.
-*   **Static Locations**: Users can save "Home", "Work", or "School" addresses for quick selection.
-*   **Geocoding**: Converts coordinates to readable addresses (and vice-versa).
+
+* **Live Location Stream**: During SOS, app sends location via WebSocket about every 5 seconds.
+* **Cleaner GPS Data**: App filters bad/noisy points before sending and sends a keepalive point if updates are silent for too long.
+* **Foreground/Background Handling**: If app is open it tracks in foreground; if app is in background it switches to background tracking.
+* **Static Locations**: Users can save "Home", "Work", or "School" addresses for quick selection.
+* **Geocoding**: Converts coordinates to readable addresses (and vice-versa).
 
 ### Implementation
-*   **Routes**: `/api/locations/v1/*`
-*   **Codebase**:
-    *   [Location.service.mjs](file:///src/api/Location/Location.service.mjs): Handles storage and retrieval of location data.
-    *   [socket/handlers/location.handler.mjs](file:///src/socket/handlers/location.handler.mjs): Processes `LOCATION_UPDATE` events and broadcasts to relevant rooms.
+
+* **Routes**: `/api/locations/v1/*`
+* **Codebase**:
+  * [Location.service.mjs](file:///src/api/Location/Location.service.mjs): Handles storage and retrieval of location data.
+  * [socket/handlers/location.handler.mjs](file:///src/socket/handlers/location.handler.mjs): Receives `location:update`, confirms save with `location:updated`, and pushes live updates to tracking and emergency rooms.
 
 ---
 
 ## 7. Notification System
+
 **Goal**: Multi-channel alerting for critical events.
 
 ### Features
-*   **Push Notifications**: Firebase Cloud Messaging (FCM) for app alerts.
-*   **SMS Alerts**: Fast2SMS integration for OTPs and critical SOS alerts to emergency contacts.
-*   **In-App Notifications**: Persistent notification history within the app.
+
+* **Push Notifications**: Firebase Cloud Messaging (FCM) for app alerts.
+* **SMS Alerts**: Fast2SMS integration for OTPs and critical SOS alerts to emergency contacts.
+* **In-App Notifications**: Persistent notification history within the app.
 
 ### Implementation
-*   **Codebase**:
-    *   [Notification.model.mjs](file:///src/api/Notifications/v1/Notification.model.mjs): Schema for storing notification history.
-    *   [socket/handlers/notification.handler.mjs](file:///src/socket/handlers/notification.handler.mjs): Real-time delivery to connected sockets.
+
+* **Codebase**:
+  * [Notification.model.mjs](file:///src/api/Notifications/v1/Notification.model.mjs): Schema for storing notification history.
+  * [socket/handlers/notification.handler.mjs](file:///src/socket/handlers/notification.handler.mjs): Real-time delivery to connected sockets.
 
 ---
 
 ## 8. NGO Management
+
 **Goal**: Integrate larger organizations for disaster response.
 
 ### Features
-*   **Resource Management**: NGOs can list available ambulances, supplies, and personnel.
-*   **Disaster Mode**: Special protocols for handling mass-casualty events or natural disasters.
+
+* **Resource Management**: NGOs can list available ambulances, supplies, and personnel.
+* **Disaster Mode**: Special protocols for handling mass-casualty events or natural disasters.
 
 ### Implementation
-*   **Routes**: `/api/ngo/v1/*`
-*   **Codebase**:
-    *   [NGO.model.mjs](file:///src/api/NGO/NGO.model.mjs): Schema for organization details and resources.
-    *   [NGO.controller.mjs](file:///src/api/NGO/NGO.controller.mjs): Logic for NGO onboarding and dispatch.
+
+* **Routes**: `/api/ngo/v1/*`
+* **Codebase**:
+  * [NGO.model.mjs](file:///src/api/NGO/NGO.model.mjs): Schema for organization details and resources.
+  * [NGO.controller.mjs](file:///src/api/NGO/NGO.controller.mjs): Logic for NGO onboarding and dispatch.
 
 ---
 
 ## Technology Stack Summary
-*   **Runtime**: Node.js (v20+)
-*   **Framework**: Express.js
-*   **Language**: JavaScript (ES Modules)
-*   **Database**: MongoDB (Mongoose ODM)
-*   **Real-time**: Socket.IO
-*   **AI**: LangChain + OpenAI
-*   **Containerization**: Docker
+
+* **Runtime**: Node.js (v20+)
+* **Framework**: Express.js
+* **Language**: JavaScript (ES Modules)
+* **Database**: MongoDB (Mongoose ODM)
+* **Real-time**: Socket.IO
+* **AI**: LangChain + OpenAI
+* **Containerization**: Docker
diff --git a/LifeLine-Backend/docs/20-End-to-End-Workflows.md b/LifeLine-Backend/docs/20-End-to-End-Workflows.md
index 9710787..2a49fbc 100644
--- a/LifeLine-Backend/docs/20-End-to-End-Workflows.md
+++ b/LifeLine-Backend/docs/20-End-to-End-Workflows.md
@@ -9,24 +9,29 @@ This document outlines the primary user journeys and system workflows within the
 Users can join the platform as standard users (seeking help) or helpers (providing assistance).
 
 ### A. Standard User Registration
-1.  **Sign Up**: User submits basic details (Name, Email, Phone, Password) via `POST /api/auth/v1/create/user/auth`.
-2.  **Verification**: System sends an OTP/Link to verify email/phone (if enabled).
-3.  **Profile Creation**: A basic `User` profile is created linked to their `Auth` identity.
-4.  **Login**: User logs in via `POST /api/auth/v1/login` to receive an `accessToken`.
+
+1. **Sign Up**: User submits basic details (Name, Email, Phone, Password) via `POST /api/auth/v1/create/user/auth`.
+2. **Verification**: System sends an OTP/Link to verify email/phone (if enabled).
+3. **Profile Creation**: A basic `User` profile is created linked to their `Auth` identity.
+4. **Login**: User logs in via `POST /api/auth/v1/login` to receive an `accessToken`.
 
 ### B. Helper Registration (Two Paths)
+
 **Path 1: Direct Registration**
-*   User selects "Register as Helper" during sign-up.
-*   Submits standard data **PLUS** professional details (Skills, Credentials, Pricing) in a single request.
-*   System creates both `Auth` and `Helper` profiles immediately.
+
+* User selects "Register as Helper" during sign-up.
+* Submits standard data **PLUS** professional details (Skills, Credentials, Pricing) in a single request.
+* System creates both `Auth` and `Helper` profiles immediately.
 
 **Path 2: Upgrade from User**
-*   Existing user logs in.
-*   Navigates to "Become a Helper".
-*   Submits helper details via `POST /api/helpers/v1`.
-*   System upgrades `Auth.role` to `helper` and creates the `Helper` profile.
+
+* Existing user logs in.
+* Navigates to "Become a Helper".
+* Submits helper details via `POST /api/helpers/v1`.
+* System upgrades `Auth.role` to `helper` and creates the `Helper` profile.
 
 ### Registration Flow Diagram
+
 ```mermaid
 graph TD
     A[Start: User Registration] --> B{Role Selection}
@@ -57,15 +62,16 @@ graph TD
 
 Before an emergency occurs, users are encouraged to set up their medical ID.
 
-1.  **Input Data**: User provides critical health info via `POST /api/medical/v1/create`:
-    *   **Blood Type** (e.g., O+)
-    *   **Allergies** (e.g., Peanuts - Anaphylaxis)
-    *   **Conditions** (e.g., Asthma, Diabetes)
-    *   **Emergency Contacts** (Family/Guardians)
-2.  **Storage**: Data is securely stored and linked to the `userId`.
-3.  **Usage**: This data is **automatically retrieved** and attached to any SOS alert triggered by this user, allowing helpers to see vital info immediately.
+1. **Input Data**: User provides critical health info via `POST /api/medical/v1/create`:
+    * **Blood Type** (e.g., O+)
+    * **Allergies** (e.g., Peanuts - Anaphylaxis)
+    * **Conditions** (e.g., Asthma, Diabetes)
+    * **Emergency Contacts** (Family/Guardians)
+2. **Storage**: Data is securely stored and linked to the `userId`.
+3. **Usage**: This data is **automatically retrieved** and attached to any SOS alert triggered by this user, allowing helpers to see vital info immediately.
 
 ### Medical Data Flow
+
 ```mermaid
 sequenceDiagram
     participant User
@@ -94,24 +100,26 @@ sequenceDiagram
 When a user is unsure if they need emergency help, they use the AI Triage system.
 
 ### Flow Steps
-1.  **Initiation**:
-    *   User opens Triage Chat (`POST /api/triage/start`).
-    *   AI greets the user (e.g., "Describe your symptoms").
-
-2.  **Assessment Loop**:
-    *   **User Input**: "I have chest pain and shortness of breath."
-    *   **AI Analysis**:
-        *   **Critical Check**: System scans for keywords (e.g., "heart attack", "fire"). If found -> **Immediate SOS**.
-        *   **Questioning**: If unclear, AI asks follow-up questions (max 8) to gauge severity.
-    *   **Decision**: AI determines one of three outcomes:
-        *   `need_more_info`: Ask another question.
-        *   `no_emergency`: Provide self-care advice (e.g., "Take rest").
-        *   `create_emergency`: Situation is critical.
-
-3.  **Outcome**:
-    *   If **Emergency**: System automatically triggers the SOS workflow (see below) with pre-filled data from the chat.
+
+1. **Initiation**:
+    * User opens Triage Chat (`POST /api/triage/start`).
+    * AI greets the user (e.g., "Describe your symptoms").
+
+2. **Assessment Loop**:
+    * **User Input**: "I have chest pain and shortness of breath."
+    * **AI Analysis**:
+        * **Critical Check**: System scans for keywords (e.g., "heart attack", "fire"). If found -> **Immediate SOS**.
+        * **Questioning**: If unclear, AI asks follow-up questions (max 8) to gauge severity.
+    * **Decision**: AI determines one of three outcomes:
+        * `need_more_info`: Ask another question.
+        * `no_emergency`: Provide self-care advice (e.g., "Take rest").
+        * `create_emergency`: Situation is critical.
+
+3. **Outcome**:
+    * If **Emergency**: System automatically triggers the SOS workflow (see below) with pre-filled data from the chat.
 
 ### AI Triage Logic
+
 ```mermaid
 stateDiagram-v2
     [*] --> Init: User Starts Chat
@@ -144,35 +152,43 @@ stateDiagram-v2
 The core lifecycle of an emergency event.
 
 ### Phase 1: Trigger
-*   **Manual Trigger**: User presses the SOS button in the app (`POST /api/emergency/sos`).
-*   **AI Trigger**: Triage system auto-creates the alert.
-*   **System Action**:
-    1.  Creates an `Emergency` record with status `ACTIVE`.
-    2.  Fetches user's **Medical Profile** and attaches it to the alert.
-    3.  Captures current **Location** (GPS coordinates).
+
+* **Manual Trigger**: User presses the SOS button in the app (`POST /api/emergency/sos`).
+* **AI Trigger**: Triage system auto-creates the alert.
+* **System Action**:
+    1. Creates an `Emergency` record with status `ACTIVE`.
+    2. Fetches user's **Medical Profile** and attaches it to the alert.
+    3. Captures current **Location** (GPS coordinates).
 
 ### Phase 2: Notification & Dispatch
-*   **Guardian Alert**: System notifies linked Emergency Contacts (SMS/Push).
-*   **Helper Search**:
-    1.  System queries `LocationService` for helpers within a specific radius (e.g., 5km).
-    2.  Filters helpers based on **Skills** (e.g., "CPR") required for the specific emergency type.
-*   **Broadcast**: Emits `EMERGENCY_SOS` socket event to identified helpers.
+
+* **Guardian Alert**: System notifies linked Emergency Contacts (SMS/Push).
+* **Helper Search**:
+    1. System queries `LocationService` for helpers within a specific radius (e.g., 5km).
+    2. Filters helpers based on **Skills** (e.g., "CPR") required for the specific emergency type.
+* **Broadcast**: Emits `EMERGENCY_SOS` socket event to identified helpers.
 
 ### Phase 3: Response
-*   **Helper Acceptance**: A helper accepts the request (`POST /api/emergency/{id}/accept`).
-*   **Assignment**:
-    *   System adds helper to `assignedHelpers` list.
-    *   User is notified: "Helper [Name] is on the way."
-*   **Live Tracking**: User and Helper share real-time location updates via sockets.
+
+* **Helper Acceptance**: A helper accepts the request (`POST /api/emergency/{id}/accept`).
+* **Assignment**:
+  * System adds helper to `assignedHelpers` list.
+  * User is notified: "Helper [Name] is on the way."
+* **Live Tracking**:
+  * App sends cleaned location points about every 5 seconds.
+  * If app is open, foreground tracking runs; if app is minimized, background tracking runs.
+  * Server shares these updates to all emergency participants using `emergency:locationUpdate`.
 
 ### Phase 4: Resolution
-*   **Arrival**: Helper marks status as `arrived`.
-*   **Completion**:
-    *   User or Helper marks emergency as `resolved`.
-    *   System calculates response metrics (Time to Accept, Time to Arrive).
-    *   User is prompted to review/rate the helper.
+
+* **Arrival**: Helper marks status as `arrived`.
+* **Completion**:
+  * User or Helper marks emergency as `resolved`.
+  * System calculates response metrics (Time to Accept, Time to Arrive).
+  * User is prompted to review/rate the helper.
 
 ### SOS Lifecycle Diagram
+
 ```mermaid
 sequenceDiagram
     actor Victim
diff --git a/LifeLine-Backend/docs/api-mismatch-report.md b/LifeLine-Backend/docs/api-mismatch-report.md
index 3340d58..7256269 100644
--- a/LifeLine-Backend/docs/api-mismatch-report.md
+++ b/LifeLine-Backend/docs/api-mismatch-report.md
@@ -6,18 +6,26 @@ This document details the discrepancies found between the current Frontend API c
 
 | Category | Status | Notes |
 | :--- | :--- | :--- |
-| **Auth** | ⚠️ Partial | Routes exist but some path structures differ. |
-| **User** | ❌ Mismatch | Frontend uses `/api/user/*`, Backend uses `/api/users/v1/*`. |
-| **Helper** | ❌ Mismatch | Frontend uses `/api/helper/*`, Backend uses `/api/helpers/v1/*`. |
-| **Emergency** | ✅ Mostly Match | Core flows align; new features missing. |
-| **Medical** | ❌ Mismatch | Frontend expects `/api/user/medical-info`, Backend exposes `/api/medical/v1/*`. |
+| **Auth** | ⚠️ Partial | `api.ts` has missing path params for check/verify email. |
+| **User** | ❌ Mismatch | Frontend config uses `/api/user/*`, Backend uses `/api/users/v1/*`. |
+| **Helper** | ⚠️ Partial | Frontend config is wrong, but helperSlice uses correct `/api/helpers/v1/*`. |
+| **Emergency** | ✅ Mostly Match | Core flows align; new features missing in frontend config. |
+| **Medical** | ✅ Match | Frontend `medicalSlice` uses `/api/medical/v1/*` correctly. |
+| **Notifications** | ❌ Missing | Frontend calls `/api/notifications/v1/*` but backend has no route registered. |
 | **New Features** | ❌ Missing | Payment, OTP, and Context Dispatch endpoints are absent in Frontend. |
 
 ---
 
 ## 2. Detailed Mismatches & Required Updates
 
-### A. User & Profile Routes
+### A. Auth Routes
+
+| Action | Frontend Config (`api.ts`) | Backend Actual Route | Required Frontend Change |
+| :--- | :--- | :--- | :--- |
+| **Check Email** | `GET /api/auth/v1/check-email` | `GET /api/auth/v1/check-email/:email` | Add `:email` path param |
+| **Verify Email** | `GET /api/auth/v1/verify-email` | `GET /api/auth/v1/verify-email/:token` | Add `:token` path param |
+
+### B. User & Profile Routes
 
 | Action | Frontend Config (`api.ts`) | Backend Actual Route | Required Frontend Change |
 | :--- | :--- | :--- | :--- |
@@ -25,7 +33,7 @@ This document details the discrepancies found between the current Frontend API c
 | **Update Profile** | `POST /api/user/update` | `PATCH /api/auth/v1/profile` | Change method to `PATCH` & URL to match backend |
 | **Medical Info** | `GET /api/user/medical-info` | `GET /api/medical/v1/profile/me` | Update URL to `/api/medical/v1/profile/me` |
 
-### B. Helper Routes
+### C. Helper Routes
 
 | Action | Frontend Config (`api.ts`) | Backend Actual Route | Required Frontend Change |
 | :--- | :--- | :--- | :--- |
@@ -33,7 +41,7 @@ This document details the discrepancies found between the current Frontend API c
 | **Availability** | `PATCH /api/helper/availability` | `PATCH /api/helpers/v1/:id/availability` | Update URL to include `:id` param |
 | **Search** | `GET /api/helper/nearby` | `GET /api/locations/v1/nearby/helpers` | Update URL to Location service endpoint |
 
-### C. Emergency Routes (New Features)
+### D. Emergency Routes (New Features)
 
 The following endpoints need to be added to `api.ts` to support the new features:
 
@@ -47,7 +55,7 @@ ASSIGNED: "/api/emergency/assigned/me",
 NEARBY_WITH_ASSIGNED: "/api/emergency/nearby/search?includeAssigned=true",
 ```
 
-### D. Helper Stats & Context (New Features)
+### E. Helper Stats & Context (New Features)
 
 Add these to the `HELPER` object in `api.ts`:
 
@@ -59,11 +67,24 @@ CONTEXT_DISPATCH: "/api/emergency/context-dispatch", // If applicable
 
 ---
 
-## 3. Action Plan
+## 3. Frontend Direct API Calls (Hardcoded Paths)
+
+These are direct API calls in frontend code that bypass `API_ENDPOINTS`:
+
+- `/api/helpers/v1/:id/skills` in [VerifySkillsScreen.tsx](file:///D:/projects/dr/LifeLine/Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx#L320-L330) ✅ matches backend `PATCH /api/helpers/v1/:id/skills`
+- `/api/auth/v1/getUserById/:id` in [Map.tsx](file:///D:/projects/dr/LifeLine/Lifeline-Frontend/app/(global)/Map.tsx#L202-L210) ✅ matches backend `GET /api/auth/v1/getUserById/:id`
+- `/api/notifications/v1/user/:userId` in [Notifications.tsx](file:///D:/projects/dr/LifeLine/Lifeline-Frontend/app/Helper/Notifications.tsx#L26-L38) ❌ backend does not register `/api/notifications/v1/*`
+
+## 4. Backend Route Registration Gaps
+
+Backend route registration in [server.mjs](file:///D:/projects/dr/LifeLine/LifeLine-Backend/src/server.mjs#L49-L66) does not include a Notifications router, so any `/api/notifications/*` calls will fail with 404. The Notifications module exists in docs, but no routes are wired into the server.
+
+## 5. Action Plan
 
-1.  **Refactor `api.ts`**: Update the `API_ENDPOINTS` constant in the frontend to reflect the correct Backend paths and versioning (`v1`).
-2.  **Update Services**: Modify frontend service files (e.g., `auth.service.ts`, `helper.service.ts`) to use the corrected endpoint keys.
-3.  **Implement New Logic**: Create `payment.service.ts` to handle the new Payment/OTP endpoints.
+1.  **Refactor `api.ts`**: Update the `API_ENDPOINTS` constant in the frontend to reflect the correct Backend paths and versioning (`v1`), including Auth `check-email/:email` and `verify-email/:token`.
+2.  **Align Notifications**: Either register `/api/notifications` routes in backend or update frontend to use an existing notifications endpoint if one exists.
+3.  **Update Services**: Ensure slices and screens use the updated endpoint keys (avoid hardcoded paths where possible).
+4.  **Implement New Logic**: Create `payment.service.ts` to handle the new Payment/OTP endpoints.
 
 ---
 
diff --git a/LifeLine-Backend/src/Ai/triage/triage.controller.mjs b/LifeLine-Backend/src/Ai/triage/triage.controller.mjs
index 17add28..3a5b629 100644
--- a/LifeLine-Backend/src/Ai/triage/triage.controller.mjs
+++ b/LifeLine-Backend/src/Ai/triage/triage.controller.mjs
@@ -29,13 +29,18 @@ export const TriageController = {
         });
       }
 
-      const { location, language, emergencyType } = req.body;
+      const { location, language, emergencyType, emergencyId } = req.body;
+
+      if (emergencyId) {
+        await EmergencyService.getEmergency(emergencyId, userId);
+      }
 
       const result = await TriageService.startSession(
         userId,
         location,
         language || 'en',
         emergencyType,
+        emergencyId,
       );
 
       return res.status(200).json(result);
@@ -97,8 +102,29 @@ export const TriageController = {
         try {
           const userId = result.session?.userId;
           const location = result.session?.extractedInfo?.location;
+          const existingEmergencyId = result.session?.emergencyId;
+
+          if (existingEmergencyId && userId) {
+            const emergencyUpdate = {
+              type: result.emergency?.type,
+              title: result.emergency?.title,
+              description: result.emergency?.description,
+              priority: result.emergency?.priority,
+              medicalInfo: result.emergency?.medicalInfo || {},
+            };
+
+            const emergencyResult = await EmergencyService.updateEmergencyDetails(
+              existingEmergencyId,
+              userId,
+              emergencyUpdate,
+            );
 
-          if (userId) {
+            if (emergencyResult.success) {
+              result.emergencyCreated = true;
+              result.emergencyId = existingEmergencyId;
+              result.emergencyData = emergencyResult.data;
+            }
+          } else if (userId) {
             const emergencyResult = await EmergencyService.triggerSOS(
               {
                 title: result.emergency.title,
diff --git a/LifeLine-Backend/src/Ai/triage/triageService.mjs b/LifeLine-Backend/src/Ai/triage/triageService.mjs
index 4b69a90..91433d7 100644
--- a/LifeLine-Backend/src/Ai/triage/triageService.mjs
+++ b/LifeLine-Backend/src/Ai/triage/triageService.mjs
@@ -101,11 +101,19 @@ export const TriageService = {
     location = null,
     language = 'en',
     emergencyType = null,
+    emergencyId = null,
   ) {
     // Check for existing active session
     const existingSession =
       await TriageSessionManager.getSessionByUserId(userId);
     if (existingSession) {
+      if (emergencyId && existingSession.emergencyId !== emergencyId) {
+        existingSession.setBoundEmergencyId(emergencyId);
+        await TriageSessionManager.saveSession(
+          existingSession.sessionId,
+          existingSession,
+        );
+      }
       return {
         success: true,
         sessionId: existingSession.sessionId,
@@ -117,7 +125,7 @@ export const TriageService = {
     }
 
     // Create new session
-    const state = new TriageState(userId, location, language);
+    const state = new TriageState(userId, location, language, emergencyId);
     state.setPhase(TRIAGE_PHASES.IN_PROGRESS);
 
     // Get appropriate greeting
@@ -132,6 +140,10 @@ export const TriageService = {
       state.updateExtractedInfo({ selectedType: emergencyType });
     }
 
+    if (emergencyId) {
+      state.setBoundEmergencyId(emergencyId);
+    }
+
     // Add greeting to conversation
     state.addMessage('assistant', greeting);
 
@@ -167,7 +179,8 @@ export const TriageService = {
     }
 
     // Validate ownership
-    if (state.userId !== userId) {
+    const effectiveUserId = userId || state.userId;
+    if (state.userId !== effectiveUserId) {
       return {
         success: false,
         error: 'Unauthorized access to session',
diff --git a/LifeLine-Backend/src/Ai/triage/triageState.mjs b/LifeLine-Backend/src/Ai/triage/triageState.mjs
index f71a149..b43aaa8 100644
--- a/LifeLine-Backend/src/Ai/triage/triageState.mjs
+++ b/LifeLine-Backend/src/Ai/triage/triageState.mjs
@@ -21,7 +21,12 @@ function generateSessionId() {
  * Manages the state of a triage conversation session
  */
 export class TriageState {
-  constructor(userId, location = null, language = LANGUAGES.ENGLISH) {
+  constructor(
+    userId,
+    location = null,
+    language = LANGUAGES.ENGLISH,
+    emergencyId = null,
+  ) {
     this.sessionId = generateSessionId();
     this.userId = userId;
     this.language = language;
@@ -60,7 +65,7 @@ export class TriageState {
     this.lastUpdated = new Date().toISOString();
 
     // Emergency ID (if created)
-    this.emergencyId = null;
+    this.emergencyId = emergencyId;
   }
 
   /**
@@ -135,6 +140,12 @@ export class TriageState {
     return this;
   }
 
+  setBoundEmergencyId(emergencyId) {
+    this.emergencyId = emergencyId;
+    this.lastUpdated = new Date().toISOString();
+    return this;
+  }
+
   /**
    * Get conversation history formatted for AI
    */
@@ -216,6 +227,7 @@ export class TriageState {
       data.userId,
       data.extractedInfo?.location,
       data.language,
+      data.emergencyId,
     );
     Object.assign(state, data);
     return state;
diff --git a/LifeLine-Backend/src/api/Auth/v1/Auth.model.mjs b/LifeLine-Backend/src/api/Auth/v1/Auth.model.mjs
index 9fc3f38..266d889 100644
--- a/LifeLine-Backend/src/api/Auth/v1/Auth.model.mjs
+++ b/LifeLine-Backend/src/api/Auth/v1/Auth.model.mjs
@@ -46,6 +46,11 @@ const authSchema = new mongoose.Schema(
       default: null,
     },
 
+    profileImagePublicId: {
+      type: String,
+      default: null,
+    },
+
     // Authentication
     password: {
       type: String,
diff --git a/LifeLine-Backend/src/api/Auth/v1/Auth.service.mjs b/LifeLine-Backend/src/api/Auth/v1/Auth.service.mjs
index 21299f1..6bbff16 100644
--- a/LifeLine-Backend/src/api/Auth/v1/Auth.service.mjs
+++ b/LifeLine-Backend/src/api/Auth/v1/Auth.service.mjs
@@ -31,6 +31,7 @@ class AuthService {
         password, 
         role, 
         profileImage,
+        profileImagePublicId,
         skills,
         credentials,
         pricing,
@@ -66,6 +67,7 @@ class AuthService {
           password: hashedPassword,
           role,
           profileImage,
+          profileImagePublicId,
           isVerified: false,
         });
 
@@ -78,6 +80,7 @@ class AuthService {
               fullName,
               email,
               phoneNumber: mobileNumber,
+              profileImage,
             },
             { session },
           );
diff --git a/LifeLine-Backend/src/api/Emergency/Emergency.controller.mjs b/LifeLine-Backend/src/api/Emergency/Emergency.controller.mjs
index 72a197f..175e2e1 100644
--- a/LifeLine-Backend/src/api/Emergency/Emergency.controller.mjs
+++ b/LifeLine-Backend/src/api/Emergency/Emergency.controller.mjs
@@ -233,8 +233,15 @@ export class EmergencyController {
     try {
       const { id } = req.params;
       const helperId = req.user.userId;
-
-      const result = await EmergencyService.acceptHelperRequest(id, helperId);
+      const { serviceType, amount, method } = req.body || {};
+      const parsedAmount =
+        amount === undefined || amount === null ? undefined : Number(amount);
+
+      const result = await EmergencyService.acceptHelperRequest(id, helperId, {
+        serviceType,
+        amount: Number.isFinite(parsedAmount) ? parsedAmount : undefined,
+        method,
+      });
 
       res.json(result);
     } catch (error) {
@@ -306,6 +313,75 @@ export class EmergencyController {
     }
   }
 
+  static async approveEmergencyPayment(req, res) {
+    try {
+      const { id } = req.params;
+      const userId = req.user.userId;
+
+      const result = await EmergencyService.approveEmergencyPayment(
+        id,
+        userId,
+      );
+
+      res.json(result);
+    } catch (error) {
+      const statusCode = error.message.includes('not found') ? 404 : 400;
+      res.status(statusCode).json({
+        success: false,
+        message: 'Failed to approve emergency payment',
+        error: error.message,
+      });
+    }
+  }
+
+  static async verifyEmergencyOtp(req, res) {
+    try {
+      const { id } = req.params;
+      const userId = req.user.userId;
+      const { otp } = req.body;
+
+      if (!otp) {
+        return res.status(400).json({
+          success: false,
+          message: 'OTP is required',
+        });
+      }
+
+      const result = await EmergencyService.verifyEmergencyOtp(
+        id,
+        userId,
+        otp,
+      );
+
+      res.json(result);
+    } catch (error) {
+      const statusCode = error.message.includes('not found') ? 404 : 400;
+      res.status(statusCode).json({
+        success: false,
+        message: 'Failed to verify OTP',
+        error: error.message,
+      });
+    }
+  }
+
+  static async getSOSProfile(req, res) {
+    try {
+      const { id } = req.params;
+      const helperId = req.user.userId;
+
+      const result = await EmergencyService.getSOSProfile(id, helperId);
+
+      res.json(result);
+    } catch (error) {
+      const statusCode = error.message.includes('not found') ? 404 : 403;
+      res.status(statusCode).json({
+        success: false,
+        message: 'Failed to get SOS profile',
+        error: error.message,
+      });
+    }
+  }
+
   /**
    * Update emergency status
    * @param {Object} req - Express request object
diff --git a/LifeLine-Backend/src/api/Emergency/Emergency.model.mjs b/LifeLine-Backend/src/api/Emergency/Emergency.model.mjs
index c2a3e78..888193d 100644
--- a/LifeLine-Backend/src/api/Emergency/Emergency.model.mjs
+++ b/LifeLine-Backend/src/api/Emergency/Emergency.model.mjs
@@ -91,6 +91,21 @@ const emergencySchema = new mongoose.Schema(
       maxlength: 500,
     },
 
+    medicalInfo: {
+      bloodType: String,
+      allergies: [String],
+      conditions: [String],
+      medications: [String],
+      organDonor: Boolean,
+      emergencyContacts: [
+        {
+          name: String,
+          phoneNumber: String,
+          relationship: String,
+        },
+      ],
+    },
+
   
 
     // Helper Assignments
@@ -100,6 +115,26 @@ const emergencySchema = new mongoose.Schema(
           type: mongoose.Schema.Types.ObjectId,
           ref: 'Auth',
         },
+        serviceType: {
+          type: String,
+        },
+        amount: {
+          type: Number,
+          min: 0,
+        },
+        method: {
+          type: String,
+          enum: ['cash', 'upi', 'card'],
+        },
+        paymentId: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: 'Payment',
+        },
+        paymentStatus: {
+          type: String,
+          enum: ['pending', 'approved', 'verified', 'released', 'failed', 'free'],
+          default: 'free',
+        },
         status: {
           type: String,
           enum: ['requested', 'accepted', 'arriving', 'arrived', 'completed'],
@@ -193,6 +228,84 @@ const emergencySchema = new mongoose.Schema(
       },
     },
 
+    requiredHelpers: {
+      type: Number,
+      default: 1,
+      min: 1,
+    },
+
+    serviceType: {
+      type: String,
+    },
+
+    acceptedHelpers: [
+      {
+        helperId: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: 'Auth',
+        },
+        serviceType: {
+          type: String,
+        },
+        amount: {
+          type: Number,
+          min: 0,
+        },
+        method: {
+          type: String,
+          enum: ['cash', 'upi', 'card'],
+        },
+        paymentId: {
+          type: mongoose.Schema.Types.ObjectId,
+          ref: 'Payment',
+        },
+        paymentStatus: {
+          type: String,
+          enum: ['pending', 'approved', 'verified', 'released', 'failed', 'free'],
+          default: 'free',
+        },
+        acceptedAt: Date,
+      },
+    ],
+
+    payment: {
+      status: {
+        type: String,
+        enum: ['none', 'pending', 'approved', 'verified'],
+        default: 'none',
+      },
+      paymentId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Payment',
+      },
+      helperId: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Auth',
+      },
+      amount: {
+        type: Number,
+        min: 0,
+      },
+      method: {
+        type: String,
+        enum: ['cash', 'upi', 'card'],
+      },
+      otp: {
+        type: String,
+      },
+      otpExpiresAt: Date,
+      approvedAt: Date,
+      approvedBy: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Auth',
+      },
+      verifiedAt: Date,
+      verifiedBy: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'Auth',
+      },
+    },
+
     // Resolution Details
     resolution: {
       resolvedBy: [
@@ -285,7 +398,7 @@ emergencySchema.methods.assignHelper = function (helperId) {
 };
 
 // Method to accept helper assignment
-emergencySchema.methods.acceptHelper = function (helperId) {
+emergencySchema.methods.acceptHelper = function (helperId, data = {}) {
   const assignment = this.assignedHelpers.find(
     (helper) => helper.helperId.toString() === helperId.toString(),
   );
@@ -293,6 +406,21 @@ emergencySchema.methods.acceptHelper = function (helperId) {
   if (assignment && assignment.status === 'requested') {
     assignment.status = 'accepted';
     assignment.acceptedAt = new Date();
+    if (data.serviceType) {
+      assignment.serviceType = data.serviceType;
+    }
+    if (typeof data.amount === 'number') {
+      assignment.amount = data.amount;
+    }
+    if (data.method) {
+      assignment.method = data.method;
+    }
+    if (data.paymentId) {
+      assignment.paymentId = data.paymentId;
+    }
+    if (data.paymentStatus) {
+      assignment.paymentStatus = data.paymentStatus;
+    }
 
     if (!this.responseMetrics.firstHelperAcceptedAt) {
       this.responseMetrics.firstHelperAcceptedAt = new Date();
diff --git a/LifeLine-Backend/src/api/Emergency/Emergency.routes.mjs b/LifeLine-Backend/src/api/Emergency/Emergency.routes.mjs
index 1b6179a..4242eb6 100644
--- a/LifeLine-Backend/src/api/Emergency/Emergency.routes.mjs
+++ b/LifeLine-Backend/src/api/Emergency/Emergency.routes.mjs
@@ -91,6 +91,10 @@ router.post(
   EmergencyController.sendHelperRequest,
 );
 
+router.post('/:id/approve', EmergencyController.approveEmergencyPayment);
+router.post('/:id/verify-otp', EmergencyController.verifyEmergencyOtp);
+router.get('/:id/profile', EmergencyController.getSOSProfile);
+
 // ==================== PARAMETERIZED ROUTES (MUST BE AFTER SPECIFIC ROUTES) ====================
 
 /**
diff --git a/LifeLine-Backend/src/api/Emergency/Emergency.service.mjs b/LifeLine-Backend/src/api/Emergency/Emergency.service.mjs
index e16dcf7..76dae06 100644
--- a/LifeLine-Backend/src/api/Emergency/Emergency.service.mjs
+++ b/LifeLine-Backend/src/api/Emergency/Emergency.service.mjs
@@ -19,6 +19,9 @@ import {
   notifyGuardiansOfSOS,
 } from '../../socket/handlers/notification.handler.mjs';
 import MedicalService from '../Medical/Medical.service.mjs';
+import AuthService from '../Auth/v1/Auth.service.mjs';
+import * as PaymentUtils from '../Payment/Payment.utils.mjs';
+import UserService from '../User/User.service.mjs';
 
 /**
  * Emergency Service for LifeLine Emergency Response System
@@ -270,7 +273,7 @@ export class EmergencyService {
    * @param {string} helperId - Helper ID
    * @returns {Promise<Object>} Acceptance result
    */
-  static async acceptHelperRequest(emergencyId, helperId) {
+  static async acceptHelperRequest(emergencyId, helperId, data = {}) {
     try {
       const emergency = await Emergency.findById(emergencyId);
       if (!emergency) {
@@ -283,13 +286,68 @@ export class EmergencyService {
         );
       }
 
-      const assignment = emergency.acceptHelper(helperId);
+      const { serviceType, amount, method } = data || {};
+      const paymentRequired =
+        typeof amount === 'number' && Number.isFinite(amount) && amount > 0;
+
+      let payment = null;
+      if (paymentRequired) {
+        payment = await PaymentUtils.createPayment({
+          emergencyId: emergency._id,
+          helperId,
+          userId: emergency.userId,
+          amount,
+          method: method || 'cash',
+          serviceType,
+        });
+      }
+
+      const assignment = emergency.acceptHelper(helperId, {
+        serviceType,
+        amount: paymentRequired ? amount : 0,
+        method: method || (paymentRequired ? 'cash' : undefined),
+        paymentId: payment?._id,
+        paymentStatus: paymentRequired ? 'pending' : 'free',
+      });
       if (!assignment) {
         throw new Error(
           'Helper not assigned to this emergency',
         );
       }
 
+      if (paymentRequired) {
+        emergency.payment = {
+          ...emergency.payment,
+          status: 'pending',
+          paymentId: payment?._id,
+          helperId,
+          amount,
+          method: method || 'cash',
+        };
+      }
+
+      if (serviceType) {
+        emergency.serviceType = serviceType;
+      }
+
+      if (emergency.acceptedHelpers) {
+        const existingAccepted = emergency.acceptedHelpers.find(
+          (accepted) =>
+            accepted.helperId?.toString() === helperId.toString(),
+        );
+        if (!existingAccepted) {
+          emergency.acceptedHelpers.push({
+            helperId,
+            serviceType,
+            amount: paymentRequired ? amount : 0,
+            method: method || (paymentRequired ? 'cash' : undefined),
+            paymentId: payment?._id,
+            paymentStatus: paymentRequired ? 'pending' : 'free',
+            acceptedAt: new Date(),
+          });
+        }
+      }
+
       await emergency.save();
 
       // Send notifications
@@ -515,6 +573,85 @@ export class EmergencyService {
     }
   }
 
+  static async updateEmergencyDetails(emergencyId, userId, updateData = {}) {
+    try {
+      const emergency = await Emergency.findById(emergencyId);
+      if (!emergency) {
+        throw new Error(EmergencyConstants.MESSAGES.ERROR.EMERGENCY_NOT_FOUND);
+      }
+
+      const ownerId = emergency.userId?._id || emergency.userId;
+      if (!ownerId || ownerId.toString() !== userId.toString()) {
+        throw new Error(EmergencyConstants.MESSAGES.ERROR.UNAUTHORIZED);
+      }
+
+      const allowedUpdates = {};
+
+      if (updateData.type) {
+        if (
+          !Object.values(EmergencyConstants.EMERGENCY_TYPES).includes(
+            updateData.type,
+          )
+        ) {
+          throw new Error(EmergencyConstants.MESSAGES.VALIDATION.INVALID_TYPE);
+        }
+        allowedUpdates.type = updateData.type;
+      }
+
+      if (updateData.title) {
+        if (updateData.title.length > 100) {
+          throw new Error(
+            EmergencyConstants.MESSAGES.VALIDATION.TITLE_TOO_LONG,
+          );
+        }
+        allowedUpdates.title = updateData.title;
+      }
+
+      if (updateData.description) {
+        if (updateData.description.length > 500) {
+          throw new Error(
+            EmergencyConstants.MESSAGES.VALIDATION.DESCRIPTION_TOO_LONG,
+          );
+        }
+        allowedUpdates.description = updateData.description;
+      }
+
+      if (updateData.priority) {
+        if (
+          !Object.values(EmergencyConstants.EMERGENCY_PRIORITIES).includes(
+            updateData.priority,
+          )
+        ) {
+          throw new Error(
+            EmergencyConstants.MESSAGES.VALIDATION.INVALID_PRIORITY,
+          );
+        }
+        allowedUpdates.priority = updateData.priority;
+      }
+
+      if (updateData.medicalInfo) {
+        allowedUpdates.medicalInfo = updateData.medicalInfo;
+      }
+
+      if (Object.keys(allowedUpdates).length === 0) {
+        return {
+          success: true,
+          data: emergency,
+        };
+      }
+
+      emergency.set(allowedUpdates);
+      await emergency.save();
+
+      return {
+        success: true,
+        data: emergency,
+      };
+    } catch (error) {
+      throw new Error(`Failed to update emergency: ${error.message}`);
+    }
+  }
+
   /**
    * Get user's emergencies
    * @param {string} userId - User ID
@@ -828,6 +965,248 @@ export class EmergencyService {
     return [];
   }
 
+  static async approveEmergencyPayment(emergencyId, userId) {
+    try {
+      const emergency = await Emergency.findById(emergencyId);
+      if (!emergency) {
+        throw new Error('Emergency not found');
+      }
+
+      const ownerId = emergency.userId?._id || emergency.userId;
+      if (!ownerId || ownerId.toString() !== userId) {
+        throw new Error('Unauthorized to approve payment');
+      }
+
+      if (emergency.status !== EmergencyConstants.EMERGENCY_STATUSES.RESOLVED) {
+        throw new Error('Payment can only be approved after resolution');
+      }
+
+      if (!emergency.payment?.paymentId) {
+        throw new Error('Payment not required for this emergency');
+      }
+
+      if (emergency.payment?.status !== 'pending') {
+        throw new Error('Payment is not pending approval');
+      }
+
+      const otp = Math.floor(100000 + Math.random() * 900000).toString();
+      const otpExpiresAt = new Date(Date.now() + 5 * 60 * 1000);
+
+      emergency.payment = {
+        ...emergency.payment,
+        status: 'approved',
+        otp,
+        otpExpiresAt,
+        approvedAt: new Date(),
+        approvedBy: userId,
+      };
+
+      if (emergency.payment?.paymentId) {
+        await PaymentUtils.updatePaymentStatus(
+          emergency.payment.paymentId,
+          'approved',
+        );
+      }
+
+      if (emergency.acceptedHelpers?.length) {
+        emergency.acceptedHelpers = emergency.acceptedHelpers.map((item) => {
+          if (
+            emergency.payment?.helperId &&
+            item.helperId?.toString() === emergency.payment.helperId.toString()
+          ) {
+            return {
+              ...item,
+              paymentStatus: 'approved',
+            };
+          }
+          return item;
+        });
+      }
+
+      if (emergency.assignedHelpers?.length) {
+        emergency.assignedHelpers = emergency.assignedHelpers.map((item) => {
+          if (
+            emergency.payment?.helperId &&
+            item.helperId?.toString() === emergency.payment.helperId.toString()
+          ) {
+            return {
+              ...item,
+              paymentStatus: 'approved',
+            };
+          }
+          return item;
+        });
+      }
+
+      await emergency.save();
+
+      const Auth = mongoose.model('Auth');
+      const auth = await Auth.findById(userId).select('phoneNumber').lean();
+      let otpSent = false;
+
+      if (auth?.phoneNumber) {
+        try {
+          await AuthService.sendOTP(auth.phoneNumber, otp);
+          otpSent = true;
+        } catch (error) {
+          otpSent = false;
+        }
+      }
+
+      return {
+        success: true,
+        message: otpSent ? 'OTP sent successfully' : 'OTP generated',
+        data: {
+          emergencyId: emergency._id,
+          otpSent,
+        },
+      };
+    } catch (error) {
+      throw new Error(`Failed to approve emergency payment: ${error.message}`);
+    }
+  }
+
+  static async verifyEmergencyOtp(emergencyId, userId, otp) {
+    try {
+      const emergency = await Emergency.findById(emergencyId);
+      if (!emergency) {
+        throw new Error('Emergency not found');
+      }
+
+      const ownerId = emergency.userId?._id || emergency.userId;
+      if (!ownerId || ownerId.toString() !== userId) {
+        throw new Error('Unauthorized to verify OTP');
+      }
+
+      if (emergency.status !== EmergencyConstants.EMERGENCY_STATUSES.RESOLVED) {
+        throw new Error('Payment can only be verified after resolution');
+      }
+
+      const payment = emergency.payment || {};
+      if (!payment.otp || payment.status !== 'approved') {
+        throw new Error('OTP not available for verification');
+      }
+
+      if (payment.otpExpiresAt && payment.otpExpiresAt < new Date()) {
+        throw new Error('OTP expired');
+      }
+
+      if (payment.otp !== otp) {
+        throw new Error('Invalid OTP');
+      }
+
+      emergency.payment = {
+        ...payment,
+        status: 'verified',
+        otp: undefined,
+        otpExpiresAt: undefined,
+        verifiedAt: new Date(),
+        verifiedBy: userId,
+      };
+
+      if (emergency.payment?.paymentId) {
+        await PaymentUtils.updatePaymentStatus(
+          emergency.payment.paymentId,
+          'released',
+        );
+      }
+
+      if (emergency.acceptedHelpers?.length) {
+        emergency.acceptedHelpers = emergency.acceptedHelpers.map((item) => {
+          if (
+            emergency.payment?.helperId &&
+            item.helperId?.toString() === emergency.payment.helperId.toString()
+          ) {
+            return {
+              ...item,
+              paymentStatus: 'released',
+            };
+          }
+          return item;
+        });
+      }
+
+      if (emergency.assignedHelpers?.length) {
+        emergency.assignedHelpers = emergency.assignedHelpers.map((item) => {
+          if (
+            emergency.payment?.helperId &&
+            item.helperId?.toString() === emergency.payment.helperId.toString()
+          ) {
+            return {
+              ...item,
+              paymentStatus: 'released',
+            };
+          }
+          return item;
+        });
+      }
+
+      await emergency.save();
+
+      return {
+        success: true,
+        message: 'OTP verified successfully',
+        data: {
+          emergencyId: emergency._id,
+          paymentStatus: emergency.payment?.status,
+        },
+      };
+    } catch (error) {
+      throw new Error(`Failed to verify OTP: ${error.message}`);
+    }
+  }
+
+  static async getSOSProfile(emergencyId, helperId) {
+    try {
+      const emergency = await Emergency.findById(emergencyId);
+      if (!emergency) {
+        throw new Error('Emergency not found');
+      }
+
+      const isAssignedHelper = emergency.assignedHelpers.some((assignment) => {
+        const assignedId = assignment.helperId?._id || assignment.helperId;
+        return assignedId && assignedId.toString() === helperId.toString();
+      });
+
+      if (!isAssignedHelper) {
+        throw new Error('Unauthorized to access SOS profile');
+      }
+
+      const userProfile = await UserService.getUserByAuthId(emergency.userId);
+
+      let medicalSnapshot = null;
+      try {
+        medicalSnapshot = await MedicalService.getMedicalInfoByUserId(
+          emergency.userId,
+        );
+      } catch (error) {
+        medicalSnapshot = null;
+      }
+
+      const historyCount = await Emergency.countDocuments({
+        userId: emergency.userId,
+      });
+
+      return {
+        success: true,
+        data: {
+          userProfile,
+          medicalSnapshot,
+          emergencySummary: {
+            emergencyId: emergency._id,
+            type: emergency.type,
+            status: emergency.status,
+            priority: emergency.priority,
+            location: emergency.location,
+            historyCount,
+          },
+        },
+      };
+    } catch (error) {
+      throw new Error(`Failed to get SOS profile: ${error.message}`);
+    }
+  }
+
   /**
    * Check if user has access to emergency
    * @param {Object} emergency - Emergency object
diff --git a/LifeLine-Backend/src/api/Helper/Helper.controller.mjs b/LifeLine-Backend/src/api/Helper/Helper.controller.mjs
index 43a4bcb..8355450 100644
--- a/LifeLine-Backend/src/api/Helper/Helper.controller.mjs
+++ b/LifeLine-Backend/src/api/Helper/Helper.controller.mjs
@@ -160,6 +160,24 @@ export default class HelperController {
     }
   }
 
+  static async getHelperStats(req, res) {
+    try {
+      const { id } = req.params;
+      console.log('HelperController.getHelperStats:', id);
+      const metrics = await HelperService.getDashboardMetrics(id);
+
+      res.status(200).json({
+        success: true,
+        data: metrics,
+      });
+    } catch (error) {
+      res.status(400).json({
+        success: false,
+        message: error.message,
+      });
+    }
+  }
+
   /**
    * Update helper profile
    * @param {Object} req - Express request object
diff --git a/LifeLine-Backend/src/api/Helper/Helper.model.mjs b/LifeLine-Backend/src/api/Helper/Helper.model.mjs
index de766f4..02b2dbd 100644
--- a/LifeLine-Backend/src/api/Helper/Helper.model.mjs
+++ b/LifeLine-Backend/src/api/Helper/Helper.model.mjs
@@ -105,6 +105,26 @@ const helperSchema = new mongoose.Schema(
       type: String,
       default: '95%',
     },
+
+    totalEarnings: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    pendingAmount: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    casesSolved: {
+      type: Number,
+      default: 0,
+      min: 0,
+    },
+    activeCase: {
+      type: Boolean,
+      default: false,
+    },
   },
   {
     timestamps: true,
diff --git a/LifeLine-Backend/src/api/Helper/Helper.routes.mjs b/LifeLine-Backend/src/api/Helper/Helper.routes.mjs
index 326eff7..79fd42e 100644
--- a/LifeLine-Backend/src/api/Helper/Helper.routes.mjs
+++ b/LifeLine-Backend/src/api/Helper/Helper.routes.mjs
@@ -22,6 +22,7 @@ router.patch(
 );
 // /api/helpers/v1/checkCurrentAvailability/699ac6a6e6b3b33cff46e09b
 router.post('/', AuthMiddleware.authenticate, HelperController.createHelper);
+router.get('/stats/:id', HelperController.getHelperStats);
 router.get('/:id', HelperController.getHelper);
 router.get('/:id/dashboard', HelperController.getDashboardMetrics);
 router.get(
diff --git a/LifeLine-Backend/src/api/Helper/Helper.service.mjs b/LifeLine-Backend/src/api/Helper/Helper.service.mjs
index 78b7af1..b0d78b0 100644
--- a/LifeLine-Backend/src/api/Helper/Helper.service.mjs
+++ b/LifeLine-Backend/src/api/Helper/Helper.service.mjs
@@ -2,6 +2,7 @@ import Helper from './Helper.model.mjs';
 import HelperUtils from './Helper.utils.mjs';
 import AuthUtils from '../Auth/v1/Auth.utils.mjs';
 import HelperConstants from './Helper.constants.mjs';
+import Payment from '../Payment/Payment.model.mjs';
 import AuthConstants from '../Auth/v1/Auth.constants.mjs';
 import mongoose from 'mongoose';
 import Emergency from '../Emergency/Emergency.model.mjs';
@@ -428,15 +429,25 @@ export default class HelperService {
         return false;
       }).length;
 
-      // Calculate total earnings (mock logic since Payment isn't integrated yet)
-      const totalEarnings = casesSolved * 500; // Mock 500 per solved case
-      const pendingEarnings = activeCases * 500;
+      const payments = await Payment.find({ helperId }).lean();
+      const totalEarnings = payments
+        .filter((p) => p.status === 'released')
+        .reduce((sum, p) => sum + (p.amount || 0), 0);
+      const pendingEarnings = payments
+        .filter((p) =>
+          ['pending', 'approved', 'verified'].includes(p.status),
+        )
+        .reduce((sum, p) => sum + (p.amount || 0), 0);
 
       // Format recent activity
+      const paymentByEmergency = new Map(
+        payments.map((p) => [p.emergencyId?.toString(), p]),
+      );
       const recentActivity = emergencies
         .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt))
         .slice(0, 5)
         .map((e) => {
+          const payment = paymentByEmergency.get(e._id?.toString());
           return {
             time: new Date(e.createdAt).toLocaleTimeString([], {
               hour: '2-digit',
@@ -444,7 +455,12 @@ export default class HelperService {
             }),
             title: `${e.type.charAt(0).toUpperCase() + e.type.slice(1)} Emergency`,
             status: e.status.charAt(0).toUpperCase() + e.status.slice(1),
-            payout: e.status === 'resolved' ? 500 : 0,
+            payout:
+              payment?.status === 'released'
+                ? payment.amount || 0
+                : e.status === 'resolved'
+                  ? 0
+                  : 0,
           };
         });
 
diff --git a/LifeLine-Backend/src/api/Location/Location.controller.mjs b/LifeLine-Backend/src/api/Location/Location.controller.mjs
index c6ff9e9..a58a2eb 100644
--- a/LifeLine-Backend/src/api/Location/Location.controller.mjs
+++ b/LifeLine-Backend/src/api/Location/Location.controller.mjs
@@ -3,6 +3,58 @@ import LocationService from './Location.service.mjs';
 /**
  * LocationController - Simple handlers for Location operations
  */
+const parseNearbyQueryParams = (query = {}) => {
+  const latitudeRaw = query.latitude ?? query.lat;
+  const longitudeRaw = query.longitude ?? query.lng;
+
+  if (latitudeRaw === undefined || longitudeRaw === undefined) {
+    throw new Error('Latitude and Longitude are required');
+  }
+
+  const latitude = Number(latitudeRaw);
+  const longitude = Number(longitudeRaw);
+
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    throw new Error('Invalid latitude/longitude');
+  }
+
+  const radiusKmRaw =
+    query.radiusKm !== undefined
+      ? Number(query.radiusKm)
+      : query.radiusMeters !== undefined
+        ? Number(query.radiusMeters) / 1000
+        : query.maxDistance !== undefined
+          ? Number(query.maxDistance) / 1000
+          : query.radius !== undefined
+            ? Number(query.radius)
+            : 10;
+
+  const radiusUnit = String(query.radiusUnit || '').toLowerCase();
+  let radiusKm = radiusKmRaw;
+
+  if (radiusUnit === 'm' || radiusUnit === 'meter' || radiusUnit === 'meters') {
+    radiusKm = radiusKmRaw / 1000;
+  } else if (
+    radiusUnit === 'km' ||
+    radiusUnit === 'kilometer' ||
+    radiusUnit === 'kilometers'
+  ) {
+    radiusKm = radiusKmRaw;
+  } else if (query.radius !== undefined && radiusKmRaw > 1000) {
+    // Backward compatibility: some clients pass radius in meters.
+    radiusKm = radiusKmRaw / 1000;
+  }
+
+  if (!Number.isFinite(radiusKm) || radiusKm <= 0) {
+    radiusKm = 10;
+  }
+
+  return {
+    center: { lat: latitude, lng: longitude },
+    radiusKm,
+  };
+};
+
 export default class LocationController {
   static async createLocation(req, res) {
     try {
@@ -90,18 +142,20 @@ export default class LocationController {
 
   static async searchNearbyLocations(req, res) {
     try {
-      const { latitude, longitude, radius } = req.query;
-      if (!latitude || !longitude)
-        throw new Error('Latitude and Longitude are required');
-      const center = {
-        lat: parseFloat(latitude),
-        lng: parseFloat(longitude),
-      };
+      const { center, radiusKm } = parseNearbyQueryParams(req.query);
       const locations = await LocationService.searchLocationsWithinRadius(
         center,
-        parseFloat(radius) || 10,
+        radiusKm,
       );
-      res.status(200).json({ success: true, data: locations });
+      res.status(200).json({
+        success: true,
+        data: locations,
+        meta: {
+          radiusKm,
+          center,
+          total: locations.length,
+        },
+      });
     } catch (error) {
       res.status(400).json({ success: false, message: error.message });
     }
@@ -109,23 +163,25 @@ export default class LocationController {
 
   static async searchNearbyHelpers(req, res) {
     try {
-      const { latitude, longitude, radius } = req.query;
-
+      const { center, radiusKm } = parseNearbyQueryParams(req.query);
       console.log('Searching nearby helpers with params:-->', {
-        latitude,
-        longitude,
-        radius,
+        center,
+        radiusKm,
       });
-
-      if (!latitude || !longitude)
-        throw new Error('Latitude and Longitude are required');
-      const center = { lat: parseFloat(latitude), lng: parseFloat(longitude) };
       const helpers = await LocationService.searchNearbyHelpers(
         center,
-        parseFloat(radius) || 10,
+        radiusKm,
       );
       console.log('Helpers found:-->', helpers);
-      res.status(200).json({ success: true, data: helpers });
+      res.status(200).json({
+        success: true,
+        data: helpers,
+        meta: {
+          radiusKm,
+          center,
+          total: helpers.length,
+        },
+      });
     } catch (error) {
       res.status(400).json({ success: false, message: error.message });
     }
diff --git a/LifeLine-Backend/src/api/NGO/NGO.controller.mjs b/LifeLine-Backend/src/api/NGO/NGO.controller.mjs
index 6492f33..a03be2d 100644
--- a/LifeLine-Backend/src/api/NGO/NGO.controller.mjs
+++ b/LifeLine-Backend/src/api/NGO/NGO.controller.mjs
@@ -2,6 +2,58 @@ import NGOPayment from './NGOPayment.model.mjs';
 import * as NGOPaymentUtils from './NGOPayment.utils.mjs';
 import NGO from './NGO.model.mjs';
 
+const parseNearbyQueryParams = (query = {}) => {
+  const latitudeRaw = query.latitude ?? query.lat;
+  const longitudeRaw = query.longitude ?? query.lng;
+
+  if (latitudeRaw === undefined || longitudeRaw === undefined) {
+    throw new Error('Latitude and longitude are required.');
+  }
+
+  const latitude = Number(latitudeRaw);
+  const longitude = Number(longitudeRaw);
+
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+    throw new Error('Invalid coordinates provided.');
+  }
+
+  const radiusKmRaw =
+    query.radiusKm !== undefined
+      ? Number(query.radiusKm)
+      : query.radiusMeters !== undefined
+        ? Number(query.radiusMeters) / 1000
+        : query.maxDistance !== undefined
+          ? Number(query.maxDistance) / 1000
+          : query.radius !== undefined
+            ? Number(query.radius)
+            : 10;
+
+  const radiusUnit = String(query.radiusUnit || '').toLowerCase();
+  let radiusKm = radiusKmRaw;
+
+  if (radiusUnit === 'm' || radiusUnit === 'meter' || radiusUnit === 'meters') {
+    radiusKm = radiusKmRaw / 1000;
+  } else if (
+    radiusUnit === 'km' ||
+    radiusUnit === 'kilometer' ||
+    radiusUnit === 'kilometers'
+  ) {
+    radiusKm = radiusKmRaw;
+  } else if (query.radius !== undefined && radiusKmRaw > 1000) {
+    // Backward compatibility: some clients pass radius in meters.
+    radiusKm = radiusKmRaw / 1000;
+  }
+
+  if (!Number.isFinite(radiusKm) || radiusKm <= 0) {
+    radiusKm = 10;
+  }
+
+  return {
+    center: { lat: latitude, lng: longitude },
+    radiusKm,
+  };
+};
+
 /**
  * NGOController - API handlers for NGO operations
  * @author Senior Software Engineer
@@ -105,44 +157,41 @@ export default class NGOController {
    */
   static async getNearby(req, res) {
     try {
-      const { latitude, longitude, radius = 10000 } = req.query; // Default radius 10km
-
-      if (!latitude || !longitude) {
-        return res.status(400).json({
-          success: false,
-          message: 'Latitude and longitude are required.',
-        });
-      }
-
-      const parsedLongitude = parseFloat(longitude);
-      const parsedLatitude = parseFloat(latitude);
+      const { center, radiusKm } = parseNearbyQueryParams(req.query);
 
-      if (isNaN(parsedLongitude) || isNaN(parsedLatitude)) {
-        return res.status(400).json({
-          success: false,
-          message: 'Invalid coordinates provided.',
-        });
-      }
-
-      const NGOs = await NGO.find({
-        'location.coordinates': {
-          $near: {
-            $geometry: {
+      const NGOs = await NGO.aggregate([
+        {
+          $geoNear: {
+            near: {
               type: 'Point',
-              coordinates: [parsedLongitude, parsedLatitude],
+              coordinates: [center.lng, center.lat],
             },
-            $maxDistance: parseInt(radius),
+            distanceField: 'distanceMeters',
+            maxDistance: Math.round(radiusKm * 1000),
+            spherical: true,
+            query: { registrationStatus: 'approved' }, // Only approved NGOs
           },
         },
-        registrationStatus: 'approved', // Only fetch approved NGOs
-      });
+      ]);
+
+      const formattedNGOs = NGOs.map((ngo) => ({
+        ...ngo,
+        id: ngo._id?.toString(),
+        distanceKm: Number((ngo.distanceMeters / 1000).toFixed(2)),
+        distance: `${(ngo.distanceMeters / 1000).toFixed(1)} km`,
+      }));
 
       res.status(200).json({
         success: true,
-        data: NGOs,
+        data: formattedNGOs,
+        meta: {
+          radiusKm,
+          center,
+          total: formattedNGOs.length,
+        },
       });
     } catch (error) {
-      res.status(500).json({
+      res.status(400).json({
         success: false,
         message: `Failed to get nearby NGOs: ${error.message}`,
       });
diff --git a/LifeLine-Backend/src/api/Notifications/v1/Notification.controller.mjs b/LifeLine-Backend/src/api/Notifications/v1/Notification.controller.mjs
new file mode 100644
index 0000000..a711d0b
--- /dev/null
+++ b/LifeLine-Backend/src/api/Notifications/v1/Notification.controller.mjs
@@ -0,0 +1,158 @@
+import Notification from './Notification.model.mjs';
+
+/**
+ * Notification Controller
+ * Handles fetching and updating user notifications
+ */
+export const NotificationController = {
+  /**
+   * Get all notifications for the authenticated user
+   */
+  async getNotifications(req, res) {
+    try {
+      const userId = req.user.userId;
+      const { page = 1, limit = 20, type } = req.query;
+
+      const query = {
+        'recipient.userId': userId,
+      };
+
+      if (type) {
+        query.type = type;
+      }
+
+      const notifications = await Notification.find(query)
+        .sort({ createdAt: -1 })
+        .skip((page - 1) * limit)
+        .limit(parseInt(limit));
+
+      const total = await Notification.countDocuments(query);
+      const unreadCount = await Notification.countDocuments({
+        ...query,
+        'channels.push.status': { $ne: 'read' },
+      });
+
+      res.status(200).json({
+        success: true,
+        data: notifications,
+        pagination: {
+          page: parseInt(page),
+          limit: parseInt(limit),
+          total,
+          pages: Math.ceil(total / limit),
+        },
+        unreadCount,
+      });
+    } catch (error) {
+      console.error('Get notifications error:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to fetch notifications',
+        error: error.message,
+      });
+    }
+  },
+
+  /**
+   * Get unread notification count
+   */
+  async getUnreadCount(req, res) {
+    try {
+      const userId = req.user.userId;
+
+      const count = await Notification.countDocuments({
+        'recipient.userId': userId,
+        'channels.push.status': { $ne: 'read' },
+      });
+
+      res.status(200).json({
+        success: true,
+        count,
+      });
+    } catch (error) {
+      console.error('Get unread count error:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to get unread count',
+        error: error.message,
+      });
+    }
+  },
+
+  /**
+   * Mark a specific notification as read
+   */
+  async markAsRead(req, res) {
+    try {
+      const userId = req.user.userId;
+      const { id } = req.params;
+
+      const notification = await Notification.findOne({
+        _id: id,
+        'recipient.userId': userId,
+      });
+
+      if (!notification) {
+        return res.status(404).json({
+          success: false,
+          message: 'Notification not found',
+        });
+      }
+
+      // Update status to read
+      notification.channels.push.status = 'read';
+      notification.channels.push.readAt = new Date();
+      await notification.save();
+
+      res.status(200).json({
+        success: true,
+        message: 'Notification marked as read',
+        data: notification,
+      });
+    } catch (error) {
+      console.error('Mark as read error:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to mark notification as read',
+        error: error.message,
+      });
+    }
+  },
+
+  /**
+   * Mark all notifications as read
+   */
+  async markAllAsRead(req, res) {
+    try {
+      const userId = req.user.userId;
+
+      const result = await Notification.updateMany(
+        {
+          'recipient.userId': userId,
+          'channels.push.status': { $ne: 'read' },
+        },
+        {
+          $set: {
+            'channels.push.status': 'read',
+            'channels.push.readAt': new Date(),
+          },
+        }
+      );
+
+      res.status(200).json({
+        success: true,
+        message: 'All notifications marked as read',
+        count: result.modifiedCount,
+      });
+    } catch (error) {
+      console.error('Mark all read error:', error);
+      res.status(500).json({
+        success: false,
+        message: 'Failed to mark all notifications as read',
+        error: error.message,
+      });
+    }
+  },
+};
+
+export default NotificationController;
diff --git a/LifeLine-Backend/src/api/Notifications/v1/Notification.routes.mjs b/LifeLine-Backend/src/api/Notifications/v1/Notification.routes.mjs
new file mode 100644
index 0000000..6ed9718
--- /dev/null
+++ b/LifeLine-Backend/src/api/Notifications/v1/Notification.routes.mjs
@@ -0,0 +1,27 @@
+import express from 'express';
+import NotificationController from './Notification.controller.mjs';
+import AuthMiddleware from '../../Auth/v1/Auth.middleware.mjs';
+
+const router = express.Router();
+
+// Apply authentication middleware to all routes
+router.use(AuthMiddleware.authenticate);
+
+/**
+ * Notification Routes
+ * Base Path: /api/notifications/v1
+ */
+
+// Get all notifications with pagination
+router.get('/', NotificationController.getNotifications);
+
+// Get unread count
+router.get('/unread-count', NotificationController.getUnreadCount);
+
+// Mark all as read
+router.patch('/read-all', NotificationController.markAllAsRead);
+
+// Mark specific notification as read
+router.patch('/:id/read', NotificationController.markAsRead);
+
+export default router;
diff --git a/LifeLine-Backend/src/api/Payment/Payment.controller.mjs b/LifeLine-Backend/src/api/Payment/Payment.controller.mjs
new file mode 100644
index 0000000..12d097e
--- /dev/null
+++ b/LifeLine-Backend/src/api/Payment/Payment.controller.mjs
@@ -0,0 +1,34 @@
+import * as PaymentUtils from './Payment.utils.mjs';
+
+export default class PaymentController {
+  static async createPayment(req, res) {
+    try {
+      const { emergencyId, helperId, userId, amount, method, serviceType } =
+        req.body;
+      const payment = await PaymentUtils.createPayment({
+        emergencyId,
+        helperId,
+        userId,
+        amount,
+        method,
+        serviceType,
+      });
+      res.status(201).json({ success: true, data: payment });
+    } catch (error) {
+      res.status(400).json({ success: false, message: error.message });
+    }
+  }
+
+  static async releasePayment(req, res) {
+    try {
+      const { paymentId } = req.params;
+      const payment = await PaymentUtils.updatePaymentStatus(
+        paymentId,
+        'released',
+      );
+      res.status(200).json({ success: true, data: payment });
+    } catch (error) {
+      res.status(400).json({ success: false, message: error.message });
+    }
+  }
+}
diff --git a/LifeLine-Backend/src/api/Payment/Payment.model.mjs b/LifeLine-Backend/src/api/Payment/Payment.model.mjs
new file mode 100644
index 0000000..77a1801
--- /dev/null
+++ b/LifeLine-Backend/src/api/Payment/Payment.model.mjs
@@ -0,0 +1,55 @@
+import mongoose from 'mongoose';
+
+const PaymentSchema = new mongoose.Schema({
+  emergencyId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Emergency',
+    required: true,
+    index: true,
+  },
+  helperId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Auth',
+    required: true,
+    index: true,
+  },
+  userId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Auth',
+    required: true,
+    index: true,
+  },
+  amount: {
+    type: Number,
+    required: true,
+    min: 0,
+  },
+  status: {
+    type: String,
+    enum: ['pending', 'approved', 'verified', 'released', 'failed'],
+    default: 'pending',
+  },
+  method: {
+    type: String,
+    enum: ['cash', 'upi', 'card'],
+    required: true,
+  },
+  serviceType: {
+    type: String,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+  updatedAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+PaymentSchema.pre('save', function (next) {
+  this.updatedAt = Date.now();
+  next();
+});
+
+export default mongoose.model('Payment', PaymentSchema);
diff --git a/LifeLine-Backend/src/api/Payment/Payment.routes.mjs b/LifeLine-Backend/src/api/Payment/Payment.routes.mjs
new file mode 100644
index 0000000..310723b
--- /dev/null
+++ b/LifeLine-Backend/src/api/Payment/Payment.routes.mjs
@@ -0,0 +1,12 @@
+import express from 'express';
+import PaymentController from './Payment.controller.mjs';
+import AuthMiddleware from '../Auth/v1/Auth.middleware.mjs';
+
+const router = express.Router();
+
+router.use(AuthMiddleware.authenticate);
+
+router.post('/', PaymentController.createPayment);
+router.patch('/:paymentId/release', PaymentController.releasePayment);
+
+export default router;
diff --git a/LifeLine-Backend/src/api/Payment/Payment.utils.mjs b/LifeLine-Backend/src/api/Payment/Payment.utils.mjs
new file mode 100644
index 0000000..e13a04e
--- /dev/null
+++ b/LifeLine-Backend/src/api/Payment/Payment.utils.mjs
@@ -0,0 +1,21 @@
+import Payment from './Payment.model.mjs';
+
+export async function createPayment(data) {
+  return Payment.create(data);
+}
+
+export async function getPaymentById(paymentId) {
+  return Payment.findById(paymentId);
+}
+
+export async function getPaymentsByEmergency(emergencyId) {
+  return Payment.find({ emergencyId }).sort({ createdAt: -1 });
+}
+
+export async function getPaymentsByHelper(helperId) {
+  return Payment.find({ helperId }).sort({ createdAt: -1 });
+}
+
+export async function updatePaymentStatus(paymentId, status) {
+  return Payment.findByIdAndUpdate(paymentId, { status }, { new: true });
+}
diff --git a/LifeLine-Backend/src/api/User/User.service.mjs b/LifeLine-Backend/src/api/User/User.service.mjs
index 061ec6c..4112afd 100644
--- a/LifeLine-Backend/src/api/User/User.service.mjs
+++ b/LifeLine-Backend/src/api/User/User.service.mjs
@@ -23,6 +23,7 @@ export default class UserService {
         fullName,
         email,
         phoneNumber,
+        profileImage,
         dateOfBirth,
         gender,
         address,
@@ -67,6 +68,7 @@ export default class UserService {
         fullName: sanitizedData.fullName,
         email: sanitizedData.email,
         phoneNumber: sanitizedData.phoneNumber,
+        profileImage,
         dateOfBirth,
         gender,
         address,
@@ -165,6 +167,7 @@ export default class UserService {
       // Update fields
       const allowedUpdates = [
         'fullName',
+        'profileImage',
         'phoneNumber',
         'dateOfBirth',
         'gender',
diff --git a/LifeLine-Backend/src/api/User/User.utils.mjs b/LifeLine-Backend/src/api/User/User.utils.mjs
index 1f53cdc..4afbe22 100644
--- a/LifeLine-Backend/src/api/User/User.utils.mjs
+++ b/LifeLine-Backend/src/api/User/User.utils.mjs
@@ -90,6 +90,7 @@ export default class UserUtils {
       fullName: user.fullName,
       email: user.email,
       phoneNumber: user.phoneNumber,
+      profileImage: user.profileImage,
       dateOfBirth: user.dateOfBirth,
       gender: user.gender,
       address: user.address,
diff --git a/LifeLine-Backend/src/config/mongo.config.mjs b/LifeLine-Backend/src/config/mongo.config.mjs
index c73c1a9..c8fe611 100644
--- a/LifeLine-Backend/src/config/mongo.config.mjs
+++ b/LifeLine-Backend/src/config/mongo.config.mjs
@@ -12,9 +12,12 @@ const connectDB = async () => {
       (process.env.NODE_ENV === 'test'
         ? process.env.TEST_MONGODB_URI || process.env.MONGODB_URI
         : process.env.MONGODB_URI) || 'mongodb://localhost:27017/lifeline';
+    const normalizedMongoURI =
+      typeof mongoURI === 'string' ? mongoURI.trim() : mongoURI;
 
     // Connection options for better performance and reliability
     const options = {
+      family: 4,
       // Automatically create indexes
       autoIndex: true,
 
@@ -29,7 +32,7 @@ const connectDB = async () => {
     };
 
     // Connect to MongoDB
-    const conn = await mongoose.connect(mongoURI, options);
+    const conn = await mongoose.connect(normalizedMongoURI, options);
 
     console.log(`✅ MongoDB Connected: ${conn.connection.host}`);
     console.log(`📂 Database: ${conn.connection.name}`);
diff --git a/LifeLine-Backend/src/server.mjs b/LifeLine-Backend/src/server.mjs
index db86123..31c60d8 100644
--- a/LifeLine-Backend/src/server.mjs
+++ b/LifeLine-Backend/src/server.mjs
@@ -4,6 +4,8 @@ import http from 'http';
 import cors from 'cors';
 import dotenv from 'dotenv';
 import cookieParser from 'cookie-parser';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { connectDB, disconnectDB } from './config/mongo.config.mjs';
 import { initializeSocket } from './config/socket.config.mjs';
 import { setupSocketHandlers } from './socket/index.mjs';
@@ -11,6 +13,9 @@ import { setupSocketHandlers } from './socket/index.mjs';
 // Load environment variables
 dotenv.config();
 
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 // Initialize Express app
 const app = express();
 
@@ -32,6 +37,7 @@ app.use(
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 app.use(cookieParser());
+app.use('/uploads', express.static(path.join(__dirname, 'uploads')));
 
 // Health check endpoint
 app.get('/health', (req, res) => {
@@ -54,6 +60,8 @@ import locationRoutes from './api/Location/Location.routes.mjs';
 import emergencyRoutes from './api/Emergency/Emergency.routes.mjs';
 import triageRoutes from './Ai/triage/triage.routes.mjs';
 import ngoRoutes from './api/NGO/NGO.routes.mjs';
+import notificationRoutes from './api/Notifications/v1/Notification.routes.mjs';
+import paymentRoutes from './api/Payment/Payment.routes.mjs';
 
 // Use API routes with versioning
 app.use('/api/auth/v1', authRoutes);
@@ -64,6 +72,8 @@ app.use('/api/locations/v1', locationRoutes);
 app.use('/api/emergency', emergencyRoutes);
 app.use('/api/triage', triageRoutes);
 app.use('/api/ngo/v1', ngoRoutes);
+app.use('/api/notifications/v1', notificationRoutes);
+app.use('/api/payments', paymentRoutes);
 
 // 404 handler
 app.use((req, res) => {
diff --git a/LifeLine-Backend/src/socket/SOCKET_API.md b/LifeLine-Backend/src/socket/SOCKET_API.md
index be7010a..13c3991 100644
--- a/LifeLine-Backend/src/socket/SOCKET_API.md
+++ b/LifeLine-Backend/src/socket/SOCKET_API.md
@@ -37,7 +37,8 @@ Server now knows this user is online.
 
 ## Step 3 — User sends location
 
-Server always knows user’s latest location.
+While SOS is active, the app sends location about every 5 seconds.
+Before sending, the app removes noisy GPS points.
 
 ## Step 4 — User triggers SOS
 
@@ -92,20 +93,28 @@ User or helper sends location regularly.
 
 ```js
 socket.emit('location:update', {
+  // required
   latitude,
   longitude,
+
+  // optional but recommended
   accuracy,
   timestamp,
   altitude,
   speed,
-  heading
+  heading,
+
+  // optional metadata (identity already comes from user:register)
+  userId,
+  role
 });
 ```
 
 Server confirms:
 
 ```js
-socket.on('location:updated', (data) => {});
+socket.on('location:updated', (data) => {}); // your update was saved
+socket.on('emergency:locationUpdate', (data) => {}); // room gets live map update
 ```
 
 ---
diff --git a/LifeLine-Backend/src/socket/handlers/triage.handler.mjs b/LifeLine-Backend/src/socket/handlers/triage.handler.mjs
index 8b1992b..a9fa186 100644
--- a/LifeLine-Backend/src/socket/handlers/triage.handler.mjs
+++ b/LifeLine-Backend/src/socket/handlers/triage.handler.mjs
@@ -51,13 +51,18 @@ export const registerTriageHandlers = (io, socket) => {
         return;
       }
 
-      const { location, language, emergencyType } = data;
+      const { location, language, emergencyType, emergencyId } = data;
+
+      if (emergencyId) {
+        await EmergencyService.getEmergency(emergencyId, userId);
+      }
 
       const result = await TriageService.startSession(
         userId,
         location,
         language || 'en',
         emergencyType,
+        emergencyId,
       );
 
       socket.emit(TRIAGE_EVENTS.SESSION_STARTED, result);
@@ -65,6 +70,7 @@ export const registerTriageHandlers = (io, socket) => {
       // Store session ID on socket for easy access
       if (result.success) {
         socket.triageSessionId = result.sessionId;
+        socket.triageEmergencyId = emergencyId || null;
       }
 
       console.log(
@@ -113,6 +119,7 @@ export const registerTriageHandlers = (io, socket) => {
       const result = await TriageService.processMessage(
         effectiveSessionId,
         message.trim(),
+        socket.userId,
       );
 
       if (!result.success) {
@@ -142,12 +149,35 @@ export const registerTriageHandlers = (io, socket) => {
             message: result.message,
           });
 
-          // Create emergency
+          // Create or update emergency
           try {
             const userId = result.session?.userId || socket.userId;
             const location = result.session?.extractedInfo?.location;
+            const existingEmergencyId =
+              result.session?.emergencyId || socket.triageEmergencyId;
+
+            if (existingEmergencyId && userId) {
+              const emergencyResult =
+                await EmergencyService.updateEmergencyDetails(
+                  existingEmergencyId,
+                  userId,
+                  {
+                    type: result.emergency?.type,
+                    title: result.emergency?.title,
+                    description: result.emergency?.description,
+                    priority: result.emergency?.priority,
+                    medicalInfo: result.emergency?.medicalInfo || {},
+                  },
+                );
 
-            if (userId) {
+              if (emergencyResult.success) {
+                socket.emit(TRIAGE_EVENTS.EMERGENCY_CREATED, {
+                  success: true,
+                  emergencyId: existingEmergencyId,
+                  emergency: emergencyResult.data,
+                });
+              }
+            } else if (userId) {
               const emergencyResult = await EmergencyService.triggerSOS(
                 {
                   title: result.emergency.title,
diff --git a/LifeLine-Backend/src/uploads/profile-pictures/feebfa2d-e8e7-42e8-a624-b3fa5915f48c-1772334762120-49172070.jpeg b/LifeLine-Backend/src/uploads/profile-pictures/feebfa2d-e8e7-42e8-a624-b3fa5915f48c-1772334762120-49172070.jpeg
new file mode 100644
index 0000000..3c58b89
Binary files /dev/null and b/LifeLine-Backend/src/uploads/profile-pictures/feebfa2d-e8e7-42e8-a624-b3fa5915f48c-1772334762120-49172070.jpeg differ
diff --git a/LifeLine-Backend/src/utils/cloudinary.utils.mjs b/LifeLine-Backend/src/utils/cloudinary.utils.mjs
new file mode 100644
index 0000000..ddfdff5
--- /dev/null
+++ b/LifeLine-Backend/src/utils/cloudinary.utils.mjs
@@ -0,0 +1,135 @@
+import axios from 'axios';
+import crypto from 'crypto';
+import fs from 'fs/promises';
+import path from 'path';
+
+const DEFAULT_FOLDER = 'lifeline/profile-pictures';
+
+const sanitizePublicId = (value) => {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9/_-]+/g, '_')
+    .replace(/_+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .slice(0, 120);
+};
+
+const getMimeTypeFromPath = (filePath) => {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === '.png') return 'image/png';
+  if (extension === '.gif') return 'image/gif';
+  if (extension === '.webp') return 'image/webp';
+  if (extension === '.heic') return 'image/heic';
+  if (extension === '.heif') return 'image/heif';
+  return 'image/jpeg';
+};
+
+class CloudinaryUtils {
+  static isConfigured() {
+    return Boolean(
+      process.env.CLOUDINARY_CLOUD_NAME &&
+        process.env.CLOUDINARY_API_KEY &&
+        process.env.CLOUDINARY_API_SECRET,
+    );
+  }
+
+  static getConfig() {
+    if (!this.isConfigured()) {
+      throw new Error(
+        'Cloudinary is not configured. Set CLOUDINARY_CLOUD_NAME, CLOUDINARY_API_KEY, and CLOUDINARY_API_SECRET.',
+      );
+    }
+
+    return {
+      cloudName: process.env.CLOUDINARY_CLOUD_NAME,
+      apiKey: process.env.CLOUDINARY_API_KEY,
+      apiSecret: process.env.CLOUDINARY_API_SECRET,
+      folder: process.env.CLOUDINARY_PROFILE_FOLDER || DEFAULT_FOLDER,
+    };
+  }
+
+  static generateSignature(params, apiSecret) {
+    const serialized = Object.entries(params)
+      .filter(([, value]) => value !== undefined && value !== null && value !== '')
+      .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
+      .map(([key, value]) => `${key}=${value}`)
+      .join('&');
+
+    return crypto
+      .createHash('sha1')
+      .update(`${serialized}${apiSecret}`)
+      .digest('hex');
+  }
+
+  static async uploadImageDataUri(dataUri, options = {}) {
+    const { cloudName, apiKey, apiSecret, folder } = this.getConfig();
+    const timestamp = Math.floor(Date.now() / 1000);
+    const publicId = sanitizePublicId(
+      options.publicIdSeed || `profile_${timestamp}_${Math.round(Math.random() * 1e6)}`,
+    );
+    const targetFolder = options.folder || folder;
+
+    const signature = this.generateSignature(
+      {
+        folder: targetFolder,
+        public_id: publicId,
+        timestamp,
+      },
+      apiSecret,
+    );
+
+    const body = new URLSearchParams();
+    body.append('file', dataUri);
+    body.append('api_key', apiKey);
+    body.append('timestamp', String(timestamp));
+    body.append('signature', signature);
+    body.append('public_id', publicId);
+    if (targetFolder) {
+      body.append('folder', targetFolder);
+    }
+
+    const url = `https://api.cloudinary.com/v1_1/${cloudName}/image/upload`;
+    const response = await axios.post(url, body.toString(), {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      timeout: 30000,
+    });
+
+    return response.data;
+  }
+
+  static async uploadImageFromFile(filePath, options = {}) {
+    const buffer = await fs.readFile(filePath);
+    const mimeType = options.mimeType || getMimeTypeFromPath(filePath);
+    const dataUri = `data:${mimeType};base64,${buffer.toString('base64')}`;
+    return this.uploadImageDataUri(dataUri, options);
+  }
+
+  static async deleteImage(publicId) {
+    if (!this.isConfigured() || !publicId) return null;
+
+    const { cloudName, apiKey, apiSecret } = this.getConfig();
+    const timestamp = Math.floor(Date.now() / 1000);
+    const signature = this.generateSignature({ public_id: publicId, timestamp }, apiSecret);
+
+    const body = new URLSearchParams();
+    body.append('public_id', publicId);
+    body.append('api_key', apiKey);
+    body.append('timestamp', String(timestamp));
+    body.append('signature', signature);
+
+    const url = `https://api.cloudinary.com/v1_1/${cloudName}/image/destroy`;
+    const response = await axios.post(url, body.toString(), {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      timeout: 15000,
+    });
+
+    return response.data;
+  }
+}
+
+export default CloudinaryUtils;
diff --git a/LifeLine-Backend/src/utils/multer.utils.mjs b/LifeLine-Backend/src/utils/multer.utils.mjs
index c4cba35..2242724 100644
--- a/LifeLine-Backend/src/utils/multer.utils.mjs
+++ b/LifeLine-Backend/src/utils/multer.utils.mjs
@@ -23,7 +23,14 @@ export const FILE_SIZE_LIMITS = {
 
 // Allowed file types
 export const ALLOWED_FILE_TYPES = {
-  IMAGES: ['image/jpeg', 'image/png', 'image/gif', 'image/webp'],
+  IMAGES: [
+    'image/jpeg',
+    'image/png',
+    'image/gif',
+    'image/webp',
+    'image/heic',
+    'image/heif',
+  ],
   DOCUMENTS: [
     'application/pdf',
     'application/msword',
diff --git a/Lifeline-Frontend/Dockerfile b/Lifeline-Frontend/Dockerfile
new file mode 100644
index 0000000..dc5a7e0
--- /dev/null
+++ b/Lifeline-Frontend/Dockerfile
@@ -0,0 +1,18 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+RUN npm install -g pnpm
+
+COPY package.json pnpm-lock.yaml ./
+
+RUN pnpm install --frozen-lockfile
+
+COPY . .
+
+EXPOSE 8081
+EXPOSE 19000
+EXPOSE 19001
+EXPOSE 19002
+
+CMD ["pnpm", "start", "--", "--tunnel", "--clear"]
diff --git a/Lifeline-Frontend/app.json b/Lifeline-Frontend/app.json
index 56be878..8ea339d 100644
--- a/Lifeline-Frontend/app.json
+++ b/Lifeline-Frontend/app.json
@@ -13,7 +13,8 @@
           "root": "./app"
         }
       ],
-      "@react-native-community/datetimepicker"
+      "@react-native-community/datetimepicker",
+      "./plugins/withPowerButtonSOS"
     ],
     "splash": {
       "image": "./assets/icons/icon.png",
@@ -37,10 +38,7 @@
         "NSLocationWhenInUseUsageDescription": "LifeLine needs your location to send help during emergencies.",
         "NSLocationAlwaysAndWhenInUseUsageDescription": "LifeLine needs your location to send help during emergencies even when the app is in background.",
         "NSLocationAlwaysUsageDescription": "LifeLine needs your location to send help during emergencies even when the app closed.",
-        "UIBackgroundModes": [
-          "location",
-          "fetch"
-        ],
+        "UIBackgroundModes": ["location", "fetch"],
         "NSCameraUsageDescription": "Camera is used to record emergency evidence.",
         "NSMicrophoneUsageDescription": "Microphone is used for audio recording during emergencies.",
         "NSContactsUsageDescription": "Contacts is used to send help during emergencies.",
diff --git a/Lifeline-Frontend/app/(global)/Map.tsx b/Lifeline-Frontend/app/(global)/Map.tsx
index 22009bb..80d5041 100644
--- a/Lifeline-Frontend/app/(global)/Map.tsx
+++ b/Lifeline-Frontend/app/(global)/Map.tsx
@@ -1,4 +1,4 @@
-import React, { useEffect, useState, useRef, useCallback } from "react";
+import React, { useEffect, useState, useRef, useCallback, useMemo } from "react";
 import {
   View,
   Text,
@@ -15,11 +15,14 @@ import { WebView } from "react-native-webview";
 import * as Location from "expo-location";
 import { Ionicons } from "@expo/vector-icons";
 import { socketService } from "@/src/shared/services";
-import api, { API_ENDPOINTS } from "@/src/config/api";
+import apiClient, { API_ENDPOINTS } from "@/src/config/api";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
+import { useSelector } from "react-redux";
+import { RootState } from "@/src/core/store";
 
 interface HelperData {
   id: string;
+  authId?: string | null;
   name: string;
   avatar: string;
   rating: number;
@@ -34,212 +37,1054 @@ interface Coords {
   longitude: number;
 }
 
+interface LocationFixSample {
+  coords: Coords;
+  timestamp: number;
+  accuracy?: number;
+}
+
+interface PendingJumpState {
+  coords: Coords;
+  firstSeenAt: number;
+  confirmations: number;
+}
+
+const DEFAULT_HELPER_AVATAR = "https://randomuser.me/api/portraits/women/44.jpg";
+const DEFAULT_USER_AVATAR = "https://randomuser.me/api/portraits/men/32.jpg";
+const INITIAL_HELPER_LOCATION: Coords = { latitude: 0, longitude: 0 };
+const INITIAL_USER_LOCATION: Coords = { latitude: 0, longitude: 0 };
+const MAX_ACCEPTABLE_ACCURACY_METERS = 50;
+const HARD_REJECT_ACCURACY_METERS = 150;
+const MAX_JUMP_METERS = 800;
+const MAX_REASONABLE_SPEED_MPS = 70;
+const RECENT_FIXES_WINDOW_SIZE = 5;
+const STALE_FIX_TOLERANCE_MS = 5000;
+const LARGE_JUMP_CONFIRM_DISTANCE_METERS = 220;
+const LARGE_JUMP_MATCH_RADIUS_METERS = 90;
+const LARGE_JUMP_CONFIRMATIONS_REQUIRED = 2;
+const LARGE_JUMP_CONFIRM_TIMEOUT_MS = 12000;
+
+const asSingleParam = (value: string | string[] | undefined): string | undefined =>
+  Array.isArray(value) ? value[0] : value;
+
+const normalizeRole = (value?: string): UserRole | null =>
+  value === "helper" || value === "user" ? value : null;
+
+const pickFirstString = (...values: unknown[]): string | null => {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+};
+
+const toCoords = (raw: any): Coords | null => {
+  const latitude = Number(raw?.latitude);
+  const longitude = Number(raw?.longitude);
+
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return null;
+  return { latitude, longitude };
+};
+
+const coordsFromArray = (value: unknown): Coords | null => {
+  if (!Array.isArray(value) || value.length < 2) return null;
+  const longitude = Number(value[0]);
+  const latitude = Number(value[1]);
+  if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) return null;
+  return { latitude, longitude };
+};
+
+const toTimestampMs = (value: unknown): number => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return Date.now();
+};
+
+const haversineDistanceMeters = (a: Coords, b: Coords): number => {
+  const toRad = (deg: number) => (deg * Math.PI) / 180;
+  const R = 6371000;
+  const dLat = toRad(b.latitude - a.latitude);
+  const dLon = toRad(b.longitude - a.longitude);
+  const lat1 = toRad(a.latitude);
+  const lat2 = toRad(b.latitude);
+
+  const x =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.sin(dLon / 2) * Math.sin(dLon / 2) * Math.cos(lat1) * Math.cos(lat2);
+  const y = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1 - x));
+  return R * y;
+};
+
+// Vincenty inverse formula on WGS-84 ellipsoid for high-accuracy geodesic distance.
+const geodesicDistanceMeters = (a: Coords, b: Coords): number => {
+  if (a.latitude === b.latitude && a.longitude === b.longitude) return 0;
+
+  const toRad = (deg: number) => (deg * Math.PI) / 180;
+  const A = 6378137;
+  const B = 6356752.314245;
+  const F = 1 / 298.257223563;
+
+  const phi1 = toRad(a.latitude);
+  const phi2 = toRad(b.latitude);
+  const L = toRad(b.longitude - a.longitude);
+  const U1 = Math.atan((1 - F) * Math.tan(phi1));
+  const U2 = Math.atan((1 - F) * Math.tan(phi2));
+
+  const sinU1 = Math.sin(U1);
+  const cosU1 = Math.cos(U1);
+  const sinU2 = Math.sin(U2);
+  const cosU2 = Math.cos(U2);
+
+  let lambda = L;
+  let lambdaPrev = 0;
+  let iterations = 200;
+
+  let sinSigma = 0;
+  let cosSigma = 0;
+  let sigma = 0;
+  let sinAlpha = 0;
+  let cosSqAlpha = 0;
+  let cos2SigmaM = 0;
+
+  while (iterations > 0) {
+    const sinLambda = Math.sin(lambda);
+    const cosLambda = Math.cos(lambda);
+    const sinSqSigma =
+      cosU2 * sinLambda * (cosU2 * sinLambda) +
+      (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda);
+    sinSigma = Math.sqrt(sinSqSigma);
+
+    if (sinSigma === 0) return 0;
+
+    cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+    sigma = Math.atan2(sinSigma, cosSigma);
+    sinAlpha = (cosU1 * cosU2 * sinLambda) / sinSigma;
+    cosSqAlpha = 1 - sinAlpha * sinAlpha;
+    cos2SigmaM = cosSqAlpha !== 0 ? cosSigma - (2 * sinU1 * sinU2) / cosSqAlpha : 0;
+
+    const C = (F / 16) * cosSqAlpha * (4 + F * (4 - 3 * cosSqAlpha));
+    lambdaPrev = lambda;
+    lambda =
+      L +
+      (1 - C) *
+        F *
+        sinAlpha *
+        (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+
+    if (Math.abs(lambda - lambdaPrev) <= 1e-12) break;
+    iterations -= 1;
+  }
+
+  if (iterations === 0) {
+    return haversineDistanceMeters(a, b);
+  }
+
+  const uSq = (cosSqAlpha * (A * A - B * B)) / (B * B);
+  const bigA = 1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+  const bigB = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+  const deltaSigma =
+    bigB *
+    sinSigma *
+    (cos2SigmaM +
+      (bigB / 4) *
+        (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
+          (bigB / 6) *
+            cos2SigmaM *
+            (-3 + 4 * sinSigma * sinSigma) *
+            (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+
+  return B * bigA * (sigma - deltaSigma);
+};
+
+const smoothCoords = (from: Coords, to: Coords, alpha: number): Coords => ({
+  latitude: from.latitude + (to.latitude - from.latitude) * alpha,
+  longitude: from.longitude + (to.longitude - from.longitude) * alpha,
+});
+
+const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+const median = (values: number[]): number => {
+  if (!values.length) return 0;
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+};
+
+const getMedianCoords = (samples: LocationFixSample[]): Coords | null => {
+  if (!samples.length) return null;
+  return {
+    latitude: median(samples.map((sample) => sample.coords.latitude)),
+    longitude: median(samples.map((sample) => sample.coords.longitude)),
+  };
+};
+
+const pushRecentFix = (
+  samples: LocationFixSample[],
+  nextSample: LocationFixSample
+): LocationFixSample[] => {
+  const next = [...samples, nextSample];
+  if (next.length > RECENT_FIXES_WINDOW_SIZE) {
+    next.splice(0, next.length - RECENT_FIXES_WINDOW_SIZE);
+  }
+  return next;
+};
+
+const getMovementThresholdMeters = (accuracy?: number): number => {
+  if (typeof accuracy !== "number" || !Number.isFinite(accuracy)) return 2;
+  return Math.min(12, Math.max(1.5, accuracy * 0.18));
+};
+
+const evaluateJumpConfirmation = (
+  pending: PendingJumpState | null,
+  previousCoords: Coords,
+  incomingCoords: Coords,
+  nowTs: number
+): { accept: boolean; pending: PendingJumpState | null } => {
+  const jumpDistance = geodesicDistanceMeters(previousCoords, incomingCoords);
+  if (jumpDistance < LARGE_JUMP_CONFIRM_DISTANCE_METERS) {
+    return { accept: true, pending: null };
+  }
+
+  const isPendingExpired = pending && nowTs - pending.firstSeenAt > LARGE_JUMP_CONFIRM_TIMEOUT_MS;
+  const canConfirmWithPending =
+    pending &&
+    !isPendingExpired &&
+    geodesicDistanceMeters(pending.coords, incomingCoords) <= LARGE_JUMP_MATCH_RADIUS_METERS;
+
+  if (!canConfirmWithPending) {
+    return {
+      accept: false,
+      pending: { coords: incomingCoords, firstSeenAt: nowTs, confirmations: 1 },
+    };
+  }
+
+  const nextConfirmations = pending.confirmations + 1;
+  if (nextConfirmations >= LARGE_JUMP_CONFIRMATIONS_REQUIRED) {
+    return { accept: true, pending: null };
+  }
+
+  return {
+    accept: false,
+    pending: {
+      coords: incomingCoords,
+      firstSeenAt: pending.firstSeenAt,
+      confirmations: nextConfirmations,
+    },
+  };
+};
+
 export default function MapScreen() {
   const router = useRouter();
   const webViewRef = useRef<WebView>(null);
+  const mapReadyRef = useRef(false);
+  const myLocationRef = useRef<Coords>(INITIAL_USER_LOCATION);
+  const lastOwnFixRef = useRef<{ coords: Coords; timestamp: number; accuracy?: number } | null>(
+    null
+  );
+  const lastTargetFixRef = useRef<{ coords: Coords; timestamp: number; accuracy?: number } | null>(
+    null
+  );
+  const recentOwnFixesRef = useRef<LocationFixSample[]>([]);
+  const recentTargetFixesRef = useRef<LocationFixSample[]>([]);
+  const pendingOwnJumpRef = useRef<PendingJumpState | null>(null);
+  const pendingTargetJumpRef = useRef<PendingJumpState | null>(null);
+  const bootstrapSignatureRef = useRef<string | null>(null);
+  const locationMetaRef = useRef<{
+    accuracy?: number;
+    altitude?: number;
+    speed?: number;
+    heading?: number;
+  }>({});
+
+  const auth = useSelector((state: RootState) => state.auth);
+  const authIdFromStore = auth.authId || auth.userId || null;
+  const authRole = auth.userData?.role;
+
   const {
     helperId,
     userId,
     role: roleParam,
     emergencyId,
   } = useLocalSearchParams<{
-    helperId: string;
-    userId: string;
-    role: string;
+    helperId?: string | string[];
+    userId?: string | string[];
+    role?: string | string[];
     emergencyId?: string;
   }>();
 
+  const helperIdParam = asSingleParam(helperId);
+  const userIdParam = asSingleParam(userId);
+  const roleParamValue = asSingleParam(roleParam);
+  const emergencyIdParam = asSingleParam(emergencyId);
+
   const [loading, setLoading] = useState(true);
-  const [mapReady, setMapReady] = useState(false);
+  const [isMapReady, setIsMapReady] = useState(false);
+  const [socketReady, setSocketReady] = useState(false);
+  const [targetAuthId, setTargetAuthId] = useState<string | null>(null);
+  const [resolvedSelfAuthId, setResolvedSelfAuthId] = useState<string | null>(authIdFromStore);
+
   const [helperData, setHelperData] = useState<HelperData | null>(null);
   const [userData, setUserData] = useState<{ name: string; avatar: string } | null>(null);
-  const [helperLocation, setHelperLocation] = useState<Coords>({
-    latitude: 28.6139,
-    longitude: 77.209,
-  });
-  const [userLocation, setUserLocation] = useState<Coords>({
-    latitude: 28.6239,
-    longitude: 77.219,
-  });
-  // Use ref to avoid unnecessary re-renders on location update
-  const userLocationRef = useRef(userLocation);
+  const [helperLocation, setHelperLocation] = useState<Coords>(INITIAL_HELPER_LOCATION);
+  const [userLocation, setUserLocation] = useState<Coords>(INITIAL_USER_LOCATION);
   const [eta, setEta] = useState("--");
   const [distance, setDistance] = useState("--");
   const [focusTarget, setFocusTarget] = useState<"user" | "helper">("helper");
   const [rideType, setRideType] = useState<"car" | "bike" | "foot">("car");
-  const [myRole] = useState<UserRole>((roleParam as UserRole) || "user");
+  const [myRole, setMyRole] = useState<UserRole>(
+    normalizeRole(roleParamValue) || authRole || "user"
+  );
   const [routeLoading, setRouteLoading] = useState(false);
   const [routeSource, setRouteSource] = useState<string>("");
   const [isPrimaryLoading, setIsPrimaryLoading] = useState(false);
+  const [mapHtml, setMapHtml] = useState<string>("");
+
+  const bootstrapRole = normalizeRole(roleParamValue) || normalizeRole(authRole) || "user";
+  const bootstrapSignature = useMemo(
+    () => [bootstrapRole, emergencyIdParam || "", helperIdParam || "", userIdParam || ""].join("|"),
+    [bootstrapRole, emergencyIdParam, helperIdParam, userIdParam]
+  );
+  const webViewSource = useMemo(() => ({ html: mapHtml }), [mapHtml]);
+
+  const fetchAuthById = useCallback(async (id: string) => {
+    try {
+      const res = await apiClient.get(`/api/auth/v1/getUserById/${id}`);
+      return res?.data?.user || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const fetchUserProfileById = useCallback(async (id: string) => {
+    try {
+      const res = await apiClient.get(`/api/users/v1/${id}`);
+      return res?.data?.data || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const fetchHelperProfileById = useCallback(async (id: string) => {
+    try {
+      const res = await apiClient.get(`/api/helpers/v1/${id}`);
+      return res?.data?.data || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const fetchEmergencyById = useCallback(async (id: string) => {
+    try {
+      const res = await apiClient.get(API_ENDPOINTS.EMERGENCY.GET_BY_ID(id));
+      return res?.data?.data || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const fetchLocationById = useCallback(async (id: string) => {
+    try {
+      const res = await apiClient.get(`/api/locations/v1/${id}`);
+      return res?.data?.data || null;
+    } catch {
+      return null;
+    }
+  }, []);
+
+  const postOwnLocationToMap = useCallback((coords: Coords, role: UserRole) => {
+    if (!webViewRef.current || !mapReadyRef.current) return;
+
+    webViewRef.current.postMessage(
+      JSON.stringify({
+        type: role === "helper" ? "updateHelperLocation" : "updateUserLocation",
+        latitude: coords.latitude,
+        longitude: coords.longitude,
+      })
+    );
+  }, []);
+
+  const postTargetLocationToMap = useCallback((coords: Coords, role: UserRole) => {
+    if (!webViewRef.current || !mapReadyRef.current) return;
+
+    webViewRef.current.postMessage(
+      JSON.stringify({
+        type: role === "helper" ? "updateUserLocation" : "updateHelperLocation",
+        latitude: coords.latitude,
+        longitude: coords.longitude,
+      })
+    );
+  }, []);
+
+  const getSmoothingAlpha = useCallback((accuracy?: number) => {
+    if (typeof accuracy !== "number" || !Number.isFinite(accuracy)) return 0.4;
+    if (accuracy <= 10) return 0.75;
+    if (accuracy <= 20) return 0.6;
+    if (accuracy <= 35) return 0.5;
+    return 0.35;
+  }, []);
+
+  const isUnrealisticJump = useCallback(
+    (previous: Coords, next: Coords, previousTs: number, nextTs: number) => {
+      const distanceMeters = geodesicDistanceMeters(previous, next);
+      const seconds = Math.max((nextTs - previousTs) / 1000, 1);
+      const speedMps = distanceMeters / seconds;
+      return distanceMeters > MAX_JUMP_METERS && speedMps > MAX_REASONABLE_SPEED_MPS;
+    },
+    []
+  );
+
+  const applyOwnCoords = useCallback(
+    (rawCoords: Coords, accuracy: number | undefined, timestampMs: number, role: UserRole) => {
+      if (typeof accuracy === "number" && accuracy > HARD_REJECT_ACCURACY_METERS) {
+        return;
+      }
+
+      const previous = lastOwnFixRef.current;
+      if (previous && timestampMs + STALE_FIX_TOLERANCE_MS < previous.timestamp) {
+        return;
+      }
+
+      if (
+        previous &&
+        isUnrealisticJump(previous.coords, rawCoords, previous.timestamp, timestampMs)
+      ) {
+        return;
+      }
+
+      if (
+        previous &&
+        typeof accuracy === "number" &&
+        accuracy > MAX_ACCEPTABLE_ACCURACY_METERS &&
+        geodesicDistanceMeters(previous.coords, rawCoords) > 120
+      ) {
+        return;
+      }
+
+      if (
+        previous &&
+        (typeof accuracy !== "number" || accuracy > 25) &&
+        geodesicDistanceMeters(previous.coords, rawCoords) >= LARGE_JUMP_CONFIRM_DISTANCE_METERS
+      ) {
+        const jumpDecision = evaluateJumpConfirmation(
+          pendingOwnJumpRef.current,
+          previous.coords,
+          rawCoords,
+          timestampMs
+        );
+        pendingOwnJumpRef.current = jumpDecision.pending;
+        if (!jumpDecision.accept) {
+          return;
+        }
+      } else {
+        pendingOwnJumpRef.current = null;
+      }
+
+      recentOwnFixesRef.current = pushRecentFix(recentOwnFixesRef.current, {
+        coords: rawCoords,
+        timestamp: timestampMs,
+        accuracy,
+      });
+      const stabilizedCoords = getMedianCoords(recentOwnFixesRef.current) || rawCoords;
+
+      const nextCoords = previous
+        ? smoothCoords(previous.coords, stabilizedCoords, getSmoothingAlpha(accuracy))
+        : stabilizedCoords;
+
+      if (
+        previous &&
+        geodesicDistanceMeters(previous.coords, nextCoords) < getMovementThresholdMeters(accuracy)
+      ) {
+        return;
+      }
+
+      lastOwnFixRef.current = { coords: nextCoords, timestamp: timestampMs, accuracy };
+      myLocationRef.current = nextCoords;
+
+      if (role === "helper") {
+        setHelperLocation(nextCoords);
+      } else {
+        setUserLocation(nextCoords);
+      }
+
+      postOwnLocationToMap(nextCoords, role);
+    },
+    [getSmoothingAlpha, isUnrealisticJump, postOwnLocationToMap]
+  );
+
+  const applyTargetCoords = useCallback(
+    (rawCoords: Coords, accuracy: number | undefined, timestampMs: number, role: UserRole) => {
+      if (typeof accuracy === "number" && accuracy > HARD_REJECT_ACCURACY_METERS * 1.5) {
+        return;
+      }
+
+      const previous = lastTargetFixRef.current;
+      if (previous && timestampMs + STALE_FIX_TOLERANCE_MS < previous.timestamp) {
+        return;
+      }
+
+      if (
+        previous &&
+        isUnrealisticJump(previous.coords, rawCoords, previous.timestamp, timestampMs)
+      ) {
+        return;
+      }
+
+      if (
+        previous &&
+        (typeof accuracy !== "number" || accuracy > 30) &&
+        geodesicDistanceMeters(previous.coords, rawCoords) >=
+          LARGE_JUMP_CONFIRM_DISTANCE_METERS * 1.4
+      ) {
+        const jumpDecision = evaluateJumpConfirmation(
+          pendingTargetJumpRef.current,
+          previous.coords,
+          rawCoords,
+          timestampMs
+        );
+        pendingTargetJumpRef.current = jumpDecision.pending;
+        if (!jumpDecision.accept) {
+          return;
+        }
+      } else {
+        pendingTargetJumpRef.current = null;
+      }
+
+      recentTargetFixesRef.current = pushRecentFix(recentTargetFixesRef.current, {
+        coords: rawCoords,
+        timestamp: timestampMs,
+        accuracy,
+      });
+      const stabilizedCoords = getMedianCoords(recentTargetFixesRef.current) || rawCoords;
+
+      const nextCoords = previous
+        ? smoothCoords(previous.coords, stabilizedCoords, getSmoothingAlpha(accuracy))
+        : stabilizedCoords;
+
+      if (
+        previous &&
+        geodesicDistanceMeters(previous.coords, nextCoords) < getMovementThresholdMeters(accuracy)
+      ) {
+        return;
+      }
+
+      lastTargetFixRef.current = { coords: nextCoords, timestamp: timestampMs, accuracy };
+
+      if (role === "helper") {
+        setUserLocation(nextCoords);
+      } else {
+        setHelperLocation(nextCoords);
+      }
+
+      postTargetLocationToMap(nextCoords, role);
+    },
+    [getSmoothingAlpha, isUnrealisticJump, postTargetLocationToMap]
+  );
 
   useEffect(() => {
+    setResolvedSelfAuthId(authIdFromStore || null);
+  }, [authIdFromStore]);
+
+  useEffect(() => {
+    if (bootstrapSignatureRef.current === bootstrapSignature) {
+      return;
+    }
+
+    bootstrapSignatureRef.current = bootstrapSignature;
     let isMounted = true;
-    const init = async () => {
+
+    const initializeMyLocation = async (role: UserRole): Promise<Coords | null> => {
       try {
+        if (Platform.OS === "android") {
+          await Location.enableNetworkProviderAsync().catch(() => {});
+        }
+
         const { status } = await Location.requestForegroundPermissionsAsync();
-        if (status === "granted") {
-          const loc = await Location.getCurrentPositionAsync({
+        if (status !== "granted") return null;
+
+        let bestFix: Location.LocationObject | null = null;
+        const lastKnownFix = await Location.getLastKnownPositionAsync({
+          maxAge: 15000,
+          requiredAccuracy: HARD_REJECT_ACCURACY_METERS,
+        }).catch(() => null);
+        if (lastKnownFix) {
+          bestFix = lastKnownFix;
+        }
+
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+          const fix = await Location.getCurrentPositionAsync({
             accuracy: Location.Accuracy.BestForNavigation,
+            mayShowUserSettingsDialog: true,
           });
-          if (isMounted) {
-            setUserLocation({
-              latitude: loc.coords.latitude,
-              longitude: loc.coords.longitude,
-            });
-            userLocationRef.current = {
-              latitude: loc.coords.latitude,
-              longitude: loc.coords.longitude,
-            };
+
+          if (
+            !bestFix ||
+            (fix.coords.accuracy ?? Infinity) < (bestFix.coords.accuracy ?? Infinity)
+          ) {
+            bestFix = fix;
+          }
+
+          if ((fix.coords.accuracy ?? Infinity) <= 20) {
+            break;
+          }
+
+          if (attempt < 3) {
+            await sleep(650);
           }
         }
-        // Mock data - replace with API
-        if (isMounted) {
-          setHelperData({
-            id: helperId || "helper-1",
-            name: "Dr. Sarah Chen",
-            avatar: "https://randomuser.me/api/portraits/women/44.jpg",
-            rating: 4.9,
-            role: "Emergency Responder",
-            rescues: 1247,
-          });
-          setUserData({
-            name: "John Doe",
-            avatar: "https://randomuser.me/api/portraits/men/32.jpg",
-          });
-          setHelperLocation({ latitude: 24.0849165, longitude: 85.825372 });
+
+        if (!bestFix) return null;
+
+        const accuracy = bestFix.coords.accuracy || undefined;
+        if (typeof accuracy === "number" && accuracy > HARD_REJECT_ACCURACY_METERS) {
+          return null;
         }
+
+        const coords = {
+          latitude: bestFix.coords.latitude,
+          longitude: bestFix.coords.longitude,
+        };
+
+        const timestampMs = toTimestampMs(bestFix.timestamp);
+        myLocationRef.current = coords;
+        lastOwnFixRef.current = { coords, timestamp: timestampMs, accuracy };
+        locationMetaRef.current = {
+          accuracy,
+          altitude: bestFix.coords.altitude || undefined,
+          speed: bestFix.coords.speed || undefined,
+          heading: bestFix.coords.heading || undefined,
+        };
+
+        if (!isMounted) return coords;
+        if (role === "helper") {
+          setHelperLocation(coords);
+          setUserLocation(coords);
+        } else {
+          setUserLocation(coords);
+          setHelperLocation(coords);
+        }
+        return coords;
       } catch (error) {
-        console.error("Init error:", error);
-      } finally {
-        if (isMounted) setLoading(false);
+        console.error("Failed to initialize current location:", error);
+        return null;
       }
     };
-    init();
-    return () => {
-      isMounted = false;
-    };
-  }, [helperId, userId]);
 
-  // Debounce location update to avoid rapid socket emits and UI flicker
-  useEffect(() => {
-    if (!socketService.isConnected()) socketService.connect();
-    const timeout = setTimeout(() => {
+    const bootstrap = async () => {
+      const effectiveRole = bootstrapRole;
+      const selfAuthId = authIdFromStore || null;
+      let nextTargetAuthId: string | null = null;
+      let nextHelperData: HelperData | null = null;
+      let nextUserData: { name: string; avatar: string } | null = null;
+      let initialHelperCoords: Coords | null = null;
+      let initialUserCoords: Coords | null = null;
+
+      setLoading(true);
+      setMyRole(effectiveRole);
+      setResolvedSelfAuthId(selfAuthId);
+      setSocketReady(false);
+      mapReadyRef.current = false;
+      setIsMapReady(false);
+      setTargetAuthId(null);
+      setHelperData(null);
+      setUserData(null);
+      setFocusTarget(effectiveRole === "helper" ? "user" : "helper");
+      lastOwnFixRef.current = null;
+      lastTargetFixRef.current = null;
+      recentOwnFixesRef.current = [];
+      recentTargetFixesRef.current = [];
+      pendingOwnJumpRef.current = null;
+      pendingTargetJumpRef.current = null;
+
       try {
-        socketService.updateLocation({
-          latitude: userLocation.latitude,
-          longitude: userLocation.longitude,
-          accuracy: 10,
-          altitude: 200,
-          speed: 5,
-          heading: 90,
-          userId: userId || undefined,
-        });
-      } catch (err) {
-        console.error("Socket location update failed:", err);
-      }
-    }, 300); // 300ms debounce
-    return () => clearTimeout(timeout);
-  }, [userLocation.latitude, userLocation.longitude]);
+        const myInitialCoords = await initializeMyLocation(effectiveRole);
+        if (effectiveRole === "helper") {
+          initialHelperCoords = myInitialCoords;
+          initialUserCoords = myInitialCoords;
+        } else {
+          initialUserCoords = myInitialCoords;
+          initialHelperCoords = myInitialCoords;
+        }
 
-  useEffect(() => {
-    let subscription: Location.LocationSubscription | null = null;
-    const startWatching = async () => {
-      const { status } = await Location.requestForegroundPermissionsAsync();
-      if (status === "granted") {
-        subscription = await Location.watchPositionAsync(
-          {
-            accuracy: Location.Accuracy.BestForNavigation,
-            timeInterval: 5000,
-            distanceInterval: 5,
-            mayShowUserSettingsDialog: true,
-          },
-          (loc) => {
-            // Only update state if location actually changed
-            const prev = userLocationRef.current;
-            if (prev.latitude !== loc.coords.latitude || prev.longitude !== loc.coords.longitude) {
-              const newLocation = {
-                latitude: loc.coords.latitude,
-                longitude: loc.coords.longitude,
-              };
-              setUserLocation(newLocation);
-              userLocationRef.current = newLocation;
+        const emergencyData = emergencyIdParam ? await fetchEmergencyById(emergencyIdParam) : null;
+
+        if (effectiveRole === "user") {
+          let helperCandidateId = helperIdParam;
+          if (!helperCandidateId && emergencyData?.assignedHelpers?.length > 0) {
+            const helperFromEmergency = emergencyData.assignedHelpers[0]?.helperId;
+            helperCandidateId =
+              (typeof helperFromEmergency === "string" && helperFromEmergency) ||
+              helperFromEmergency?._id ||
+              null;
+          }
+
+          if (helperCandidateId) {
+            const helperProfile = await fetchHelperProfileById(helperCandidateId);
+            let helperAuthId = pickFirstString(helperProfile?.authId);
+            let helperAuth = helperAuthId ? await fetchAuthById(helperAuthId) : null;
+
+            if (!helperAuth) {
+              const fallbackAuth = await fetchAuthById(helperCandidateId);
+              if (fallbackAuth) {
+                helperAuth = fallbackAuth;
+                helperAuthId = pickFirstString(fallbackAuth?._id, helperCandidateId);
+              }
             }
-            // Emit location update via socket (debounced by state effect)
-            if (webViewRef.current && mapReady) {
-              webViewRef.current.postMessage(
-                JSON.stringify({
-                  type: "updateUserLocation",
-                  latitude: loc.coords.latitude,
-                  longitude: loc.coords.longitude,
-                })
-              );
+
+            nextTargetAuthId = helperAuthId;
+            nextHelperData = {
+              id: pickFirstString(helperProfile?.id, helperProfile?._id, helperCandidateId) || "",
+              authId: helperAuthId,
+              name:
+                pickFirstString(helperAuth?.fullName, helperAuth?.name, helperProfile?.name) ||
+                "Emergency Helper",
+              avatar:
+                pickFirstString(helperAuth?.profileImage, helperProfile?.avatar) ||
+                DEFAULT_HELPER_AVATAR,
+              rating: Number(helperProfile?.rating ?? 4.8),
+              role: pickFirstString(helperProfile?.role, helperAuth?.role) || "Emergency Responder",
+              rescues: Number(helperProfile?.rescues ?? helperProfile?.totalRescues ?? 0),
+            };
+
+            const helperLocationId = pickFirstString(
+              helperProfile?.locationId,
+              helperAuth?.locationId
+            );
+            if (helperLocationId) {
+              const helperLocationDoc = await fetchLocationById(helperLocationId);
+              const helperCoords = coordsFromArray(helperLocationDoc?.coordinates);
+              if (helperCoords && isMounted) {
+                initialHelperCoords = helperCoords;
+                lastTargetFixRef.current = {
+                  coords: helperCoords,
+                  timestamp: Date.now(),
+                  accuracy: helperLocationDoc?.accuracy,
+                };
+                setHelperLocation(helperCoords);
+              }
             }
           }
+        } else {
+          let userCandidateId = userIdParam;
+          if (!userCandidateId) {
+            userCandidateId =
+              pickFirstString(emergencyData?.userId?._id, emergencyData?.userId) || undefined;
+          }
+
+          if (userCandidateId) {
+            let userAuth = await fetchAuthById(userCandidateId);
+            let userProfile = null;
+            let resolvedUserAuthId = userAuth
+              ? pickFirstString(userAuth?._id, userCandidateId)
+              : null;
+
+            if (!userAuth) {
+              userProfile = await fetchUserProfileById(userCandidateId);
+              resolvedUserAuthId = pickFirstString(userProfile?.authId);
+              if (resolvedUserAuthId) {
+                userAuth = await fetchAuthById(resolvedUserAuthId);
+              }
+            }
+
+            nextTargetAuthId = resolvedUserAuthId;
+            nextUserData = {
+              name:
+                pickFirstString(
+                  userAuth?.fullName,
+                  userAuth?.name,
+                  userProfile?.fullName,
+                  userProfile?.name,
+                  emergencyData?.userId?.name
+                ) || "User",
+              avatar: pickFirstString(userAuth?.profileImage) || DEFAULT_USER_AVATAR,
+            };
+
+            const userLocationId = pickFirstString(
+              userProfile?.locationId,
+              userAuth?.locationId,
+              emergencyData?.userId?.locationId
+            );
+            if (userLocationId) {
+              const userLocationDoc = await fetchLocationById(userLocationId);
+              const userCoords = coordsFromArray(userLocationDoc?.coordinates);
+              if (userCoords && isMounted) {
+                initialUserCoords = userCoords;
+                lastTargetFixRef.current = {
+                  coords: userCoords,
+                  timestamp: Date.now(),
+                  accuracy: userLocationDoc?.accuracy,
+                };
+                setUserLocation(userCoords);
+              }
+            } else {
+              const emergencyCoords = coordsFromArray(emergencyData?.location?.coordinates);
+              if (emergencyCoords && isMounted) {
+                initialUserCoords = emergencyCoords;
+                lastTargetFixRef.current = {
+                  coords: emergencyCoords,
+                  timestamp: Date.now(),
+                };
+                setUserLocation(emergencyCoords);
+              }
+            }
+          }
+        }
+      } catch (error: unknown) {
+        console.error(
+          "Map bootstrap error:",
+          getErrorMessage(error, "Failed to initialize map screen")
         );
+      } finally {
+        if (!isMounted) return;
+        const fallbackCoords = myLocationRef.current;
+        const finalHelperCoords = initialHelperCoords || fallbackCoords;
+        const finalUserCoords = initialUserCoords || fallbackCoords;
+
+        setHelperLocation(finalHelperCoords);
+        setUserLocation(finalUserCoords);
+        setMapHtml(generateMapHtml(finalHelperCoords, finalUserCoords));
+        setTargetAuthId(nextTargetAuthId);
+        if (nextHelperData) setHelperData(nextHelperData);
+        if (nextUserData) setUserData(nextUserData);
+        setLoading(false);
       }
     };
-    startWatching();
+
+    bootstrap();
+
     return () => {
-      if (subscription) subscription.remove();
+      isMounted = false;
     };
-  }, [mapReady]);
+    // `generateMapHtml` is memoized with empty deps and intentionally excluded to avoid reloading WebView.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    bootstrapRole,
+    bootstrapSignature,
+    emergencyIdParam,
+    fetchAuthById,
+    fetchEmergencyById,
+    fetchHelperProfileById,
+    fetchLocationById,
+    fetchUserProfileById,
+    helperIdParam,
+    userIdParam,
+  ]);
 
   const onWebViewMessage = useCallback((event: { nativeEvent: { data: string } }) => {
     try {
       const data = JSON.parse(event.nativeEvent.data);
-      console.log("WebView message received:", data);
-      if (data.type === "mapReady") setMapReady(true);
-      else if (data.type === "routeInfo") {
+      if (data.type === "mapReady") {
+        mapReadyRef.current = true;
+        setIsMapReady(true);
+      } else if (data.type === "routeInfo") {
         setDistance(data.distance);
         setEta(data.duration);
         if (data.source) setRouteSource(data.source);
       } else if (data.type === "routeLoading") {
         setRouteLoading(data.loading);
       }
-    } catch (e) {}
+    } catch {}
   }, []);
 
-  const getUserById = useCallback(async () => {
-    if (!userId) return null;
+  useEffect(() => {
+    if (!isMapReady) return;
 
-    try {
-      const res = await api.get(`/api/auth/v1/getUserById/${userId}`);
-      return res;
-    } catch (err: unknown) {
-      console.error("Failed to fetch user data:", getErrorMessage(err, "Failed to fetch user"));
-      return null;
+    postOwnLocationToMap(myLocationRef.current, myRole);
+
+    const targetCoords = myRole === "helper" ? userLocation : helperLocation;
+    postTargetLocationToMap(targetCoords, myRole);
+  }, [
+    helperLocation,
+    isMapReady,
+    myRole,
+    postOwnLocationToMap,
+    postTargetLocationToMap,
+    userLocation,
+  ]);
+
+  useEffect(() => {
+    if (!resolvedSelfAuthId) return;
+
+    if (!socketService.isConnected()) {
+      socketService.connect();
     }
-  }, [userId]);
+
+    socketService.registerUser(resolvedSelfAuthId, myRole);
+    const unsubscribeState = socketService.subscribeToState((state) => {
+      const isConnected = state.connectionState === "connected";
+      const ready = isConnected && state.isRegistered && state.userId === resolvedSelfAuthId;
+      setSocketReady(ready);
+    });
+
+    return () => {
+      unsubscribeState();
+      setSocketReady(false);
+    };
+  }, [myRole, resolvedSelfAuthId]);
 
   useEffect(() => {
-    const fetchUserData = async () => {
-      if (userId) {
-        const res = await getUserById();
-        if (res?.data?.user) {
-          const user = res.data.user;
-          console.log("User data fetched:", user);
-          setUserData({
-            name: user.fullName || user.name || "User",
-            avatar: user.profileImage || "https://randomuser.me/api/portraits/men/32.jpg",
-          });
+    lastTargetFixRef.current = null;
+    recentTargetFixesRef.current = [];
+    pendingTargetJumpRef.current = null;
+  }, [targetAuthId]);
+
+  useEffect(() => {
+    if (!socketReady || !emergencyIdParam) return;
+
+    socketService.joinEmergencyRoom(
+      emergencyIdParam,
+      myRole === "helper" ? "helper" : "participant"
+    );
+
+    return () => {
+      socketService.leaveEmergencyRoom(emergencyIdParam);
+    };
+  }, [socketReady, emergencyIdParam, myRole]);
+
+  useEffect(() => {
+    if (!socketReady || !targetAuthId) return;
+
+    socketService.subscribeToUser(targetAuthId);
+
+    const applyIncomingLocation = (payload: any) => {
+      const incomingUserId = pickFirstString(payload?.userId);
+      if (!incomingUserId || incomingUserId !== targetAuthId) return;
+
+      const locationPayload = payload?.location || payload;
+      const coords = toCoords(locationPayload);
+      if (!coords) return;
+
+      const accuracy =
+        typeof locationPayload?.accuracy === "number" ? locationPayload.accuracy : undefined;
+      const timestampMs = toTimestampMs(locationPayload?.timestamp || payload?.timestamp);
+      applyTargetCoords(coords, accuracy, timestampMs, myRole);
+    };
+
+    const unsubscribeDirect = socketService.onUserLocationUpdate((data) => {
+      applyIncomingLocation(data);
+    });
+
+    const unsubscribeEmergency = socketService.onEmergencyLocationUpdate((data) => {
+      applyIncomingLocation(data);
+    });
+
+    return () => {
+      socketService.unsubscribeFromUser(targetAuthId);
+      unsubscribeDirect();
+      unsubscribeEmergency();
+    };
+  }, [applyTargetCoords, myRole, socketReady, targetAuthId]);
+
+  useEffect(() => {
+    let subscription: Location.LocationSubscription | null = null;
+    let isMounted = true;
+
+    const startWatching = async () => {
+      if (Platform.OS === "android") {
+        await Location.enableNetworkProviderAsync().catch(() => {});
+      }
+
+      const { status } = await Location.requestForegroundPermissionsAsync();
+      if (status !== "granted" || !isMounted) return;
+
+      subscription = await Location.watchPositionAsync(
+        {
+          accuracy: Location.Accuracy.BestForNavigation,
+          timeInterval: 1000,
+          distanceInterval: 0.8,
+          mayShowUserSettingsDialog: true,
+        },
+        (loc) => {
+          const rawCoords = {
+            latitude: loc.coords.latitude,
+            longitude: loc.coords.longitude,
+          };
+          const accuracy = loc.coords.accuracy || undefined;
+          const timestampMs = toTimestampMs(loc.timestamp);
+          locationMetaRef.current = {
+            accuracy,
+            altitude: loc.coords.altitude || undefined,
+            speed: loc.coords.speed || undefined,
+            heading: loc.coords.heading || undefined,
+          };
+
+          applyOwnCoords(rawCoords, accuracy, timestampMs, myRole);
         }
+      );
+    };
+
+    startWatching().catch((error) => {
+      console.error("Failed to start location watcher:", error);
+    });
+
+    return () => {
+      isMounted = false;
+      if (subscription) subscription.remove();
+    };
+  }, [applyOwnCoords, myRole]);
+
+  const myLatitude = myRole === "helper" ? helperLocation.latitude : userLocation.latitude;
+  const myLongitude = myRole === "helper" ? helperLocation.longitude : userLocation.longitude;
+
+  useEffect(() => {
+    if (!socketReady) return;
+
+    const timeout = setTimeout(() => {
+      try {
+        const meta = locationMetaRef.current;
+        socketService.updateLocation({
+          latitude: myLatitude,
+          longitude: myLongitude,
+          accuracy: meta.accuracy,
+          altitude: meta.altitude,
+          speed: meta.speed,
+          heading: meta.heading,
+          timestamp: new Date().toISOString(),
+        });
+      } catch (err) {
+        console.error("Socket location update failed:", err);
+      }
+    }, 300);
+
+    return () => clearTimeout(timeout);
+  }, [myLatitude, myLongitude, socketReady]);
+
+  // Keep publishing at a fixed 5-second cadence for both user/helper roles.
+  useEffect(() => {
+    if (!socketReady) return;
+
+    const emitCurrentLocation = () => {
+      try {
+        const current = myLocationRef.current;
+        const meta = locationMetaRef.current;
+
+        socketService.updateLocation({
+          latitude: current.latitude,
+          longitude: current.longitude,
+          accuracy: meta.accuracy,
+          altitude: meta.altitude,
+          speed: meta.speed,
+          heading: meta.heading,
+          role: myRole,
+          timestamp: new Date().toISOString(),
+        });
+      } catch (err) {
+        console.error("Periodic socket location update failed:", err);
       }
     };
 
-    fetchUserData();
-    if (myRole === "helper" && userId) {
-      // helperId
-    }
-  }, [userId, getUserById, myRole]);
+    emitCurrentLocation();
+    const intervalId = setInterval(emitCurrentLocation, 5000);
+
+    return () => clearInterval(intervalId);
+  }, [myRole, socketReady]);
 
   // Open external maps for turn-by-turn navigation
   const openExternalNavigation = useCallback(() => {
     const destination = myRole === "helper" ? userLocation : helperLocation;
     const origin = myRole === "helper" ? helperLocation : userLocation;
-
-    const scheme = Platform.select({ ios: "maps:", android: "geo:" });
     const latLng = `${destination.latitude},${destination.longitude}`;
-    const label = myRole === "helper" ? "Emergency Location" : "Helper Location";
 
     // Try Google Maps first (most common)
     const googleMapsUrl = `https://www.google.com/maps/dir/?api=1&origin=${origin.latitude},${origin.longitude}&destination=${destination.latitude},${destination.longitude}&travelmode=${rideType === "car" ? "driving" : rideType === "bike" ? "bicycling" : "walking"}`;
@@ -255,7 +1100,7 @@ export default function MapScreen() {
   }, [myRole, userLocation, helperLocation, rideType]);
 
   const handlePrimaryAction = useCallback(async () => {
-    if (!emergencyId) {
+    if (!emergencyIdParam) {
       Alert.alert("Missing Emergency", "Emergency ID is required for this action.");
       return;
     }
@@ -263,11 +1108,11 @@ export default function MapScreen() {
     setIsPrimaryLoading(true);
     try {
       if (myRole === "helper") {
-        await api.put(API_ENDPOINTS.EMERGENCY.ARRIVED(emergencyId));
-        socketService.sendHelperArrived(emergencyId);
+        await apiClient.put(API_ENDPOINTS.EMERGENCY.ARRIVED(emergencyIdParam));
+        socketService.sendHelperArrived(emergencyIdParam);
         Alert.alert("Success", "Marked as arrived.");
       } else {
-        await api.put(API_ENDPOINTS.EMERGENCY.CANCEL(emergencyId), {
+        await apiClient.put(API_ENDPOINTS.EMERGENCY.CANCEL(emergencyIdParam), {
           status: "cancelled",
           cancellationReason: "Cancelled from map view",
         });
@@ -275,24 +1120,19 @@ export default function MapScreen() {
         router.back();
       }
     } catch (error: unknown) {
-      Alert.alert(
-        "Action Failed",
-        getErrorMessage(error, "Failed to process emergency action")
-      );
+      Alert.alert("Action Failed", getErrorMessage(error, "Failed to process emergency action"));
     } finally {
       setIsPrimaryLoading(false);
     }
-  }, [emergencyId, myRole, router]);
-
-  const generateMapHtml = useCallback(() => {
-    const centerLat = (helperLocation.latitude + userLocation.latitude) / 2;
-    const centerLng = (helperLocation.longitude + userLocation.longitude) / 2;
+  }, [emergencyIdParam, myRole, router]);
 
-    // OSRM profile mapping
-    const osrmProfile =
-      rideType === "car" ? "driving" : rideType === "bike" ? "cycling" : "walking";
+  const generateMapHtml = useCallback(
+    (initialHelperLocation: Coords, initialUserLocation: Coords) => {
+      const centerLat = (initialHelperLocation.latitude + initialUserLocation.latitude) / 2;
+      const centerLng = (initialHelperLocation.longitude + initialUserLocation.longitude) / 2;
+      const osrmProfile = "driving";
 
-    return `
+      return `
 <!DOCTYPE html>
 <html>
 <head>
@@ -350,8 +1190,8 @@ export default function MapScreen() {
   <script src="https://unpkg.com/leaflet@1.9.4/dist/leaflet.js"><\/script>
   <script>
     // ========== CONFIGURATION ==========
-    const helperPos = [${helperLocation.latitude}, ${helperLocation.longitude}];
-    const userPos = [${userLocation.latitude}, ${userLocation.longitude}];
+    const helperPos = [${initialHelperLocation.latitude}, ${initialHelperLocation.longitude}];
+    const userPos = [${initialUserLocation.latitude}, ${initialUserLocation.longitude}];
     let currentProfile = '${osrmProfile}';
     
     // ========== MAP INITIALIZATION ==========
@@ -451,17 +1291,108 @@ export default function MapScreen() {
     // Draw initial straight line
     drawRoute([helperPos, userPos], false);
     
-    // ========== HAVERSINE DISTANCE (Accurate geodesic) ==========
-    function haversineDistance(lat1, lon1, lat2, lon2) {
-      const R = 6371; // Earth's radius in km
+    // ========== HIGH-ACCURACY DISTANCE (Vincenty on WGS-84) ==========
+    function sphericalDistanceKm(lat1, lon1, lat2, lon2) {
+      const R = 6371;
       const dLat = (lat2 - lat1) * Math.PI / 180;
       const dLon = (lon2 - lon1) * Math.PI / 180;
-      const a = Math.sin(dLat/2) * Math.sin(dLat/2) +
+      const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                 Math.cos(lat1 * Math.PI / 180) * Math.cos(lat2 * Math.PI / 180) *
-                Math.sin(dLon/2) * Math.sin(dLon/2);
-      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
+                Math.sin(dLon / 2) * Math.sin(dLon / 2);
+      const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
       return R * c;
     }
+
+    function geodesicDistanceKm(lat1, lon1, lat2, lon2) {
+      if (lat1 === lat2 && lon1 === lon2) return 0;
+
+      const toRad = (deg) => deg * Math.PI / 180;
+      const A = 6378137;
+      const B = 6356752.314245;
+      const F = 1 / 298.257223563;
+
+      const phi1 = toRad(lat1);
+      const phi2 = toRad(lat2);
+      const L = toRad(lon2 - lon1);
+      const U1 = Math.atan((1 - F) * Math.tan(phi1));
+      const U2 = Math.atan((1 - F) * Math.tan(phi2));
+
+      const sinU1 = Math.sin(U1);
+      const cosU1 = Math.cos(U1);
+      const sinU2 = Math.sin(U2);
+      const cosU2 = Math.cos(U2);
+
+      let lambda = L;
+      let prevLambda = 0;
+      let iterations = 200;
+
+      let sinSigma = 0;
+      let cosSigma = 0;
+      let sigma = 0;
+      let sinAlpha = 0;
+      let cosSqAlpha = 0;
+      let cos2SigmaM = 0;
+
+      while (iterations > 0) {
+        const sinLambda = Math.sin(lambda);
+        const cosLambda = Math.cos(lambda);
+        const sinSqSigma =
+          (cosU2 * sinLambda) * (cosU2 * sinLambda) +
+          (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) *
+            (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda);
+        sinSigma = Math.sqrt(sinSqSigma);
+
+        if (sinSigma === 0) return 0;
+
+        cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda;
+        sigma = Math.atan2(sinSigma, cosSigma);
+        sinAlpha = (cosU1 * cosU2 * sinLambda) / sinSigma;
+        cosSqAlpha = 1 - sinAlpha * sinAlpha;
+        cos2SigmaM = cosSqAlpha !== 0
+          ? cosSigma - (2 * sinU1 * sinU2) / cosSqAlpha
+          : 0;
+
+        const C = (F / 16) * cosSqAlpha * (4 + F * (4 - 3 * cosSqAlpha));
+        prevLambda = lambda;
+        lambda =
+          L +
+          (1 - C) *
+            F *
+            sinAlpha *
+            (sigma +
+              C *
+                sinSigma *
+                (cos2SigmaM +
+                  C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)));
+
+        if (Math.abs(lambda - prevLambda) <= 1e-12) break;
+        iterations -= 1;
+      }
+
+      if (iterations === 0) {
+        return sphericalDistanceKm(lat1, lon1, lat2, lon2);
+      }
+
+      const uSq = (cosSqAlpha * (A * A - B * B)) / (B * B);
+      const bigA =
+        1 +
+        (uSq / 16384) *
+          (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+      const bigB =
+        (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+      const deltaSigma =
+        bigB *
+        sinSigma *
+        (cos2SigmaM +
+          (bigB / 4) *
+            (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
+              (bigB / 6) *
+                cos2SigmaM *
+                (-3 + 4 * sinSigma * sinSigma) *
+                (-3 + 4 * cos2SigmaM * cos2SigmaM)));
+
+      return (B * bigA * (sigma - deltaSigma)) / 1000;
+    }
     
     // ========== FORMATTING ==========
     function formatDuration(minutes) {
@@ -479,8 +1410,14 @@ export default function MapScreen() {
       return km.toFixed(1) + ' km';
     }
     
-    // ========== ROUTING API CALLS ==========
-    let routingInProgress = false;
+	    // ========== ROUTING API CALLS ==========
+	    let routingInProgress = false;
+	    let routeUpdateTimer = null;
+	    let lastRouteStart = null;
+	    let lastRouteEnd = null;
+	    let lastRouteRefreshTs = 0;
+	    const MIN_ROUTE_REFRESH_METERS = 8;
+	    const MIN_ROUTE_REFRESH_INTERVAL_MS = 1200;
     
     // Calculate ETA based on distance and transport mode (realistic speeds in km/h)
     function calculateModeETA(distanceKm, profile) {
@@ -505,7 +1442,7 @@ export default function MapScreen() {
       if (routingInProgress) return null;
       routingInProgress = true;
       
-      const straightDist = haversineDistance(start[0], start[1], end[0], end[1]);
+      const straightDist = geodesicDistanceKm(start[0], start[1], end[0], end[1]);
       
       // Try OSRM first (free, no API key needed)
       // Note: OSRM demo server only has accurate duration for 'driving', so we calculate manually for others
@@ -554,16 +1491,51 @@ export default function MapScreen() {
       };
     }
     
-    // ========== UPDATE ROUTE AND SEND INFO ==========
-    async function updateRoute() {
-      const start = helperMarker.getLatLng();
-      const end = userMarker.getLatLng();
-      
-      // Send loading state
-      window.ReactNativeWebView.postMessage(JSON.stringify({
-        type: 'routeLoading',
-        loading: true
-      }));
+	    function shouldRefreshRoute(start, end, force = false) {
+	      if (force || !lastRouteStart || !lastRouteEnd) return true;
+        const startMovedMeters = geodesicDistanceKm(start.lat, start.lng, lastRouteStart.lat, lastRouteStart.lng) * 1000;
+        const endMovedMeters = geodesicDistanceKm(end.lat, end.lng, lastRouteEnd.lat, lastRouteEnd.lng) * 1000;
+	      return startMovedMeters >= MIN_ROUTE_REFRESH_METERS || endMovedMeters >= MIN_ROUTE_REFRESH_METERS;
+	    }
+
+	    function scheduleRouteUpdate(force = false) {
+	      const now = Date.now();
+	      const elapsed = now - lastRouteRefreshTs;
+	      const waitMs = force ? 0 : Math.max(0, MIN_ROUTE_REFRESH_INTERVAL_MS - elapsed);
+
+	      if (routeUpdateTimer) {
+	        clearTimeout(routeUpdateTimer);
+	        routeUpdateTimer = null;
+	      }
+
+	      routeUpdateTimer = setTimeout(() => {
+	        routeUpdateTimer = null;
+	        updateRoute(force);
+	      }, waitMs);
+	    }
+
+	    // ========== UPDATE ROUTE AND SEND INFO ==========
+	    async function updateRoute(force = false) {
+	      if (routingInProgress) {
+	        scheduleRouteUpdate(false);
+	        return;
+	      }
+
+	      const start = helperMarker.getLatLng();
+	      const end = userMarker.getLatLng();
+	      if (!shouldRefreshRoute(start, end, force)) return;
+
+	      lastRouteStart = { lat: start.lat, lng: start.lng };
+	      lastRouteEnd = { lat: end.lat, lng: end.lng };
+	      lastRouteRefreshTs = Date.now();
+	      const shouldShowLoading = force || !routeLine;
+	      
+	      if (shouldShowLoading) {
+	        window.ReactNativeWebView.postMessage(JSON.stringify({
+	          type: 'routeLoading',
+	          loading: true
+	        }));
+	      }
       
       const result = await fetchRoute([start.lat, start.lng], [end.lat, end.lng], currentProfile);
       
@@ -580,14 +1552,60 @@ export default function MapScreen() {
         }));
       }
       
-      window.ReactNativeWebView.postMessage(JSON.stringify({
-        type: 'routeLoading',
-        loading: false
-      }));
-    }
-    
-    // Initial route fetch
-    setTimeout(updateRoute, 300);
+	      if (shouldShowLoading) {
+	        window.ReactNativeWebView.postMessage(JSON.stringify({
+	          type: 'routeLoading',
+	          loading: false
+	        }));
+	      }
+	    }
+
+	    const markerAnimations = {
+	      helper: null,
+	      user: null,
+	    };
+
+	    function animateMarker(marker, markerType, lat, lng) {
+	      const from = marker.getLatLng();
+        const moveDistanceMeters = geodesicDistanceKm(from.lat, from.lng, lat, lng) * 1000;
+	      if (moveDistanceMeters < 0.7) return;
+
+	      if (moveDistanceMeters > 450) {
+	        marker.setLatLng([lat, lng]);
+	        return;
+	      }
+
+	      if (markerAnimations[markerType]) {
+	        cancelAnimationFrame(markerAnimations[markerType]);
+	        markerAnimations[markerType] = null;
+	      }
+
+	      const duration = Math.max(260, Math.min(900, moveDistanceMeters * 14));
+	      const startTs = performance.now();
+
+	      const easeInOut = (t) =>
+	        t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+
+	      const tick = (now) => {
+	        const progress = Math.min((now - startTs) / duration, 1);
+	        const eased = easeInOut(progress);
+	        const nextLat = from.lat + (lat - from.lat) * eased;
+	        const nextLng = from.lng + (lng - from.lng) * eased;
+	        marker.setLatLng([nextLat, nextLng]);
+
+	        if (progress < 1) {
+	          markerAnimations[markerType] = requestAnimationFrame(tick);
+	        } else {
+	          marker.setLatLng([lat, lng]);
+	          markerAnimations[markerType] = null;
+	        }
+	      };
+
+	      markerAnimations[markerType] = requestAnimationFrame(tick);
+	    }
+	    
+	    // Initial route fetch
+	    setTimeout(() => scheduleRouteUpdate(true), 300);
     
     // Fit bounds
     setTimeout(() => {
@@ -602,16 +1620,16 @@ export default function MapScreen() {
       try {
         const d = JSON.parse(e.data);
         
-        switch(d.type) {
-          case 'updateUserLocation':
-            userMarker.setLatLng([d.latitude, d.longitude]);
-            updateRoute();
-            break;
-            
-          case 'updateHelperLocation':
-            helperMarker.setLatLng([d.latitude, d.longitude]);
-            updateRoute();
-            break;
+	        switch(d.type) {
+	          case 'updateUserLocation':
+	            animateMarker(userMarker, 'user', d.latitude, d.longitude);
+	            scheduleRouteUpdate(false);
+	            break;
+	            
+	          case 'updateHelperLocation':
+	            animateMarker(helperMarker, 'helper', d.latitude, d.longitude);
+	            scheduleRouteUpdate(false);
+	            break;
             
           case 'zoomToUser':
             map.setView(userMarker.getLatLng(), 17, { animate: true, duration: 0.5 });
@@ -629,10 +1647,10 @@ export default function MapScreen() {
             });
             break;
             
-          case 'setRideType':
-            currentProfile = d.profile;
-            updateRoute(); // Re-fetch route with new profile
-            break;
+	          case 'setRideType':
+	            currentProfile = d.profile;
+	            scheduleRouteUpdate(true); // Re-fetch route with new profile
+	            break;
             
           case 'zoomIn':
             map.zoomIn(1, { animate: true });
@@ -657,9 +1675,11 @@ export default function MapScreen() {
   <\/script>
 </body>
 </html>`;
-  }, [helperLocation, userLocation, rideType]);
+    },
+    []
+  );
 
-  if (loading) {
+  if (loading || !mapHtml) {
     return (
       <View className="flex-1 items-center justify-center bg-slate-900">
         <ActivityIndicator size="large" color="#3b82f6" />
@@ -673,7 +1693,7 @@ export default function MapScreen() {
       {/* MAP */}
       <WebView
         ref={webViewRef}
-        source={{ html: generateMapHtml() }}
+        source={webViewSource}
         style={{ flex: 1 }}
         originWhitelist={["*"]}
         geolocationEnabled
diff --git a/Lifeline-Frontend/app/(global)/SOSActiveAIScreen.tsx b/Lifeline-Frontend/app/(global)/SOSActiveAIScreen.tsx
index 948e559..f55e08b 100644
--- a/Lifeline-Frontend/app/(global)/SOSActiveAIScreen.tsx
+++ b/Lifeline-Frontend/app/(global)/SOSActiveAIScreen.tsx
@@ -1,12 +1,5 @@
 import React, { useState } from "react";
-import {
-  View,
-  Text,
-  FlatList,
-  TextInput,
-  TouchableOpacity,
-  SafeAreaView,
-} from "react-native";
+import { View, Text, FlatList, TextInput, TouchableOpacity, SafeAreaView } from "react-native";
 import { Ionicons } from "@expo/vector-icons";
 
 type Sender = "ai" | "user";
@@ -29,8 +22,7 @@ export default function SOSActiveAIScreen() {
     {
       id: "1",
       sender: "ai",
-      text:
-        "Hello. I am the LifeLine Emergency Assistant. I can guide you through immediate first aid protocols while emergency services are en route. How can I help you right now?",
+      text: "Hello. I am the LifeLine Emergency Assistant. I can guide you through immediate first aid protocols while emergency services are en route. How can I help you right now?",
     },
     {
       id: "2",
@@ -52,8 +44,7 @@ export default function SOSActiveAIScreen() {
         },
         {
           id: 3,
-          text:
-            "Push hard and fast: at least 2 inches deep, 100-120 beats per minute.",
+          text: "Push hard and fast: at least 2 inches deep, 100-120 beats per minute.",
         },
       ],
       rhythm: true,
@@ -79,8 +70,7 @@ export default function SOSActiveAIScreen() {
       const aiMsg: ChatMessage = {
         id: Date.now().toString() + "ai",
         sender: "ai",
-        text:
-          "Emergency guidance continuing. Ensure airway is clear and continue compressions.",
+        text: "Emergency guidance continuing. Ensure airway is clear and continue compressions.",
       };
       setMessages((prev) => [...prev, aiMsg]);
     }, 1200);
@@ -90,24 +80,16 @@ export default function SOSActiveAIScreen() {
     const isAI = item.sender === "ai";
 
     return (
-      <View
-        className={`w-full mb-4 ${
-          isAI ? "items-start" : "items-end"
-        }`}
-      >
+      <View className={`mb-4 w-full ${isAI ? "items-start" : "items-end"}`}>
         <View
           className={`max-w-[85%] rounded-2xl p-4 ${
-            isAI
-              ? "bg-zinc-100 dark:bg-zinc-800"
-              : "bg-blue-600"
+            isAI ? "bg-zinc-100 dark:bg-zinc-800" : "bg-blue-600"
           }`}
         >
           {item.text && (
             <Text
               className={`text-sm leading-relaxed ${
-                isAI
-                  ? "text-zinc-800 dark:text-zinc-100"
-                  : "text-white"
+                isAI ? "text-zinc-800 dark:text-zinc-100" : "text-white"
               }`}
             >
               {item.text}
@@ -118,14 +100,9 @@ export default function SOSActiveAIScreen() {
           {item.steps && (
             <View className="mt-3 space-y-3">
               {item.steps.map((step) => (
-                <View
-                  key={step.id}
-                  className="flex-row items-start"
-                >
-                  <View className="w-6 h-6 rounded-full bg-blue-500 items-center justify-center mr-3">
-                    <Text className="text-white text-xs font-bold">
-                      {step.id}
-                    </Text>
+                <View key={step.id} className="flex-row items-start">
+                  <View className="mr-3 h-6 w-6 items-center justify-center rounded-full bg-blue-500">
+                    <Text className="text-xs font-bold text-white">{step.id}</Text>
                   </View>
                   <Text className="flex-1 text-sm text-zinc-700 dark:text-zinc-200">
                     {step.text}
@@ -137,11 +114,11 @@ export default function SOSActiveAIScreen() {
 
           {/* Rhythm Card */}
           {item.rhythm && (
-            <View className="mt-4 rounded-xl border border-blue-300 dark:border-blue-700 bg-blue-50 dark:bg-blue-900/30 p-3">
-              <Text className="text-blue-700 dark:text-blue-300 font-semibold text-sm">
+            <View className="mt-4 rounded-xl border border-blue-300 bg-blue-50 p-3 dark:border-blue-700 dark:bg-blue-900/30">
+              <Text className="text-sm font-semibold text-blue-700 dark:text-blue-300">
                 Rhythm Guide
               </Text>
-              <Text className="text-blue-600 dark:text-blue-200 text-xs mt-1">
+              <Text className="mt-1 text-xs text-blue-600 dark:text-blue-200">
                 I will pulse the screen at the correct CPR compression pace.
               </Text>
             </View>
@@ -166,7 +143,7 @@ export default function SOSActiveAIScreen() {
       />
 
       {/* Input Bar */}
-      <View className="absolute bottom-4 left-4 right-4 flex-row items-center bg-zinc-100 dark:bg-zinc-800 rounded-2xl px-3 py-2">
+      <View className="absolute bottom-4 left-4 right-4 flex-row items-center rounded-2xl bg-zinc-100 px-3 py-2 dark:bg-zinc-800">
         <TextInput
           value={input}
           onChangeText={setInput}
@@ -177,11 +154,11 @@ export default function SOSActiveAIScreen() {
 
         <TouchableOpacity
           onPress={sendMessage}
-          className="ml-2 w-10 h-10 rounded-full bg-blue-600 items-center justify-center"
+          className="ml-2 h-10 w-10 items-center justify-center rounded-full bg-blue-600"
         >
           <Ionicons name="arrow-up" size={18} color="white" />
         </TouchableOpacity>
       </View>
     </SafeAreaView>
   );
-}
\ No newline at end of file
+}
diff --git a/Lifeline-Frontend/app/(main)/Home.tsx b/Lifeline-Frontend/app/(main)/Home.tsx
index 302c466..36d7c2f 100644
--- a/Lifeline-Frontend/app/(main)/Home.tsx
+++ b/Lifeline-Frontend/app/(main)/Home.tsx
@@ -1,4 +1,4 @@
-import { View, Text, ScrollView, StyleSheet, TouchableOpacity } from "react-native";
+import { ScrollView, StyleSheet } from "react-native";
 import React from "react";
 import HeroSection from "@/src/features/User/Section/HeroSection";
 import WhyLifeLineSection from "@/src/features/User/Section/WhyLifeLineSec";
@@ -9,22 +9,10 @@ import { widthPercentageToDP as wp } from "react-native-responsive-screen";
 import RealImpactSection from "@/src/features/User/Section/RealImpactSection";
 import PrivacySection from "@/src/features/User/Section/PrivacySection.tsx";
 import FooterCTASection from "@/src/features/User/Component/FooterCTASection";
-import { router } from "expo-router";
 
 export default function Home() {
   const isLargeScreen = wp("100%") >= 768;
 
-  // Test function to navigate to Map with helper and user IDs
-  const goToMapWithTestIds = () => {
-    router.push({
-      pathname: "/(global)/Map",
-      params: {
-        helperId: "helper-test-123",
-        userId: "user-test-456",
-      },
-    });
-  };
-
   return (
     <ScrollView contentContainerStyle={[styles.container, isLargeScreen && styles.containerLarge]}>
       <HeroSection />
diff --git a/Lifeline-Frontend/app/(main)/Login.tsx b/Lifeline-Frontend/app/(main)/Login.tsx
index 10911f0..b4b4220 100644
--- a/Lifeline-Frontend/app/(main)/Login.tsx
+++ b/Lifeline-Frontend/app/(main)/Login.tsx
@@ -38,7 +38,7 @@ const LoginScreen = () => {
     } else {
       router.replace("/User/Dashboard");
     }
-  }, [isAuthenticated, isHydrated, userData?.role]);
+  }, [isAuthenticated, isHydrated, userData?.role, router]);
 
   const handleLogin = async () => {
     setGlobalError("");
diff --git a/Lifeline-Frontend/app/(main)/SignUp.tsx b/Lifeline-Frontend/app/(main)/SignUp.tsx
index a2a2d3d..59783a6 100644
--- a/Lifeline-Frontend/app/(main)/SignUp.tsx
+++ b/Lifeline-Frontend/app/(main)/SignUp.tsx
@@ -4,7 +4,9 @@ import MedicalInfoScreen, {
 } from "@/src/features/auth/screens/MedicalInfoScreen";
 import SecureLocationScreen from "@/src/features/auth/screens/SecureLocationScreen";
 import UserInfo from "@/src/features/auth/screens/UserInfo";
-import VerifySkillsScreen, { VerifySkillsScreenRef } from "@/src/features/auth/screens/VerifySkillsScreen";
+import VerifySkillsScreen, {
+  VerifySkillsScreenRef,
+} from "@/src/features/auth/screens/VerifySkillsScreen";
 import { useRouter } from "expo-router";
 import React, { useRef } from "react";
 import { Alert, ScrollView, StyleSheet, Text, TouchableOpacity, View } from "react-native";
@@ -149,7 +151,10 @@ const SignUp = () => {
       });
 
       if (emailExists && !latestToken) {
-        Alert.alert("Account Exists", "This email is already registered. Please login to continue.");
+        Alert.alert(
+          "Account Exists",
+          "This email is already registered. Please login to continue."
+        );
         router.replace("/Login");
         return;
       }
@@ -296,12 +301,8 @@ const SignUp = () => {
       if (!hasExistingLocation) {
         const safeLocationData = { ...(data || {}) };
         delete (safeLocationData as any).userId;
-        const longitude = Number(
-          safeLocationData.longitude ?? safeLocationData.coordinates?.[0]
-        );
-        const latitude = Number(
-          safeLocationData.latitude ?? safeLocationData.coordinates?.[1]
-        );
+        const longitude = Number(safeLocationData.longitude ?? safeLocationData.coordinates?.[0]);
+        const latitude = Number(safeLocationData.latitude ?? safeLocationData.coordinates?.[1]);
 
         if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
           Alert.alert("Invalid Location", "Please provide valid coordinates before continuing.");
diff --git a/Lifeline-Frontend/app/(main)/_layout.tsx b/Lifeline-Frontend/app/(main)/_layout.tsx
index 413ab4f..6e8fcdb 100644
--- a/Lifeline-Frontend/app/(main)/_layout.tsx
+++ b/Lifeline-Frontend/app/(main)/_layout.tsx
@@ -1,7 +1,6 @@
 import UserNav from "@/src/features/User/Component/UserNav";
 import { ThemeProvider } from "@/src/theme/ThemeContext";
 import { Slot } from "expo-router";
-import { StyleSheet, View } from "react-native";
 
 export default function Layout() {
   return (
diff --git a/Lifeline-Frontend/app/Helper/Case.tsx b/Lifeline-Frontend/app/Helper/Case.tsx
new file mode 100644
index 0000000..dbc44d4
--- /dev/null
+++ b/Lifeline-Frontend/app/Helper/Case.tsx
@@ -0,0 +1,178 @@
+import React from "react";
+import { View, Text, Image, TouchableOpacity, FlatList, SafeAreaView } from "react-native";
+import { Clock, MapPin, User } from "lucide-react-native";
+
+type Priority = "CRITICAL" | "MODERATE" | "SAFETY";
+
+interface CaseItem {
+  id: string;
+  title: string;
+  patient: string;
+  description: string;
+  name: string;
+  time: string;
+  distance: string;
+  priority: Priority;
+  avatar: string;
+}
+
+const CASES: CaseItem[] = [
+  {
+    id: "1",
+    title: "Cardiac Arrest",
+    patient: "Patient collapsed at home, unresponsive.",
+    description: "CPR in progress by family member.",
+    name: "Sarah J.",
+    time: "2m ago",
+    distance: "0.5 mi",
+    priority: "CRITICAL",
+    avatar: "https://i.pravatar.cc/100?img=47",
+  },
+  {
+    id: "2",
+    title: "Car Accident",
+    patient: "Two vehicle collision at intersection.",
+    description: "Minor injuries reported, shock.",
+    name: "Mike R.",
+    time: "8m ago",
+    distance: "2.1 mi",
+    priority: "MODERATE",
+    avatar: "https://i.pravatar.cc/100?img=12",
+  },
+  {
+    id: "3",
+    title: "Check-in Request",
+    patient: "User requested safety check-in.",
+    description: "No immediate danger reported.",
+    name: "Unknown",
+    time: "15m ago",
+    distance: "5.0 mi",
+    priority: "SAFETY",
+    avatar: "https://i.pravatar.cc/100?img=5",
+  },
+];
+
+const priorityStyles: Record<Priority, { badge: string; badgeText: string }> = {
+  CRITICAL: {
+    badge: "bg-red-100",
+    badgeText: "text-red-600",
+  },
+  MODERATE: {
+    badge: "bg-orange-100",
+    badgeText: "text-orange-600",
+  },
+  SAFETY: {
+    badge: "bg-green-100",
+    badgeText: "text-green-600",
+  },
+};
+
+const HORIZONTAL_PADDING = 16;
+
+const CaseCard = ({ item }: { item: CaseItem }) => {
+  const styles = priorityStyles[item.priority];
+
+  return (
+    <View className="mb-3 rounded-2xl border border-gray-100 bg-white p-4 shadow-sm">
+      {/* Top */}
+      <View className="flex-row items-start">
+        <Image source={{ uri: item.avatar }} className="mr-3 mt-0.5 h-12 w-12 rounded-full" />
+
+        <View className="flex-1">
+          <View className="flex-row items-start justify-between">
+            <Text className="font-semibold text-gray-800">{item.title}</Text>
+
+            <View className={`rounded-lg px-2 py-1 ${styles.badge}`}>
+              <Text className={`text-[10px] font-semibold ${styles.badgeText}`}>
+                {item.priority}
+              </Text>
+            </View>
+          </View>
+
+          <Text className="mt-1 text-xs text-gray-500">{item.patient}</Text>
+          <Text className="text-xs text-gray-500">{item.description}</Text>
+
+          {/* Meta */}
+          <View className="mt-2.5 flex-row flex-wrap items-center gap-x-3 gap-y-1">
+            <Text className="text-xs font-medium text-gray-600">{item.name}</Text>
+
+            <View className="flex-row items-center">
+              <Clock size={12} color="#6b7280" />
+              <Text className="ml-1 text-xs text-gray-500">{item.time}</Text>
+            </View>
+
+            <View className="flex-row items-center">
+              <MapPin size={12} color="#6b7280" />
+              <Text className="ml-1 text-xs text-gray-500">{item.distance}</Text>
+            </View>
+          </View>
+        </View>
+      </View>
+
+      {/* Actions */}
+      <View className="mt-4 flex-row gap-x-3">
+        <TouchableOpacity className="flex-1 items-center rounded-xl border border-gray-200 py-3.5">
+          <Text className="font-medium text-gray-600">Reject</Text>
+        </TouchableOpacity>
+
+        <TouchableOpacity className="flex-1 items-center rounded-xl bg-blue-600 py-3.5">
+          <Text className="font-semibold text-white">View SOS</Text>
+        </TouchableOpacity>
+      </View>
+    </View>
+  );
+};
+
+export default function Case() {
+  return (
+    <SafeAreaView className="flex-1 bg-gray-50">
+      {/* Header */}
+      <View className="px-4 pb-3 pt-4">
+        <View className="flex-row items-center justify-between">
+          <View>
+            <Text className="text-lg font-semibold text-gray-800">Incoming SOS</Text>
+
+            <View className="mt-1 flex-row items-center">
+              <View className="mr-2 h-2 w-2 rounded-full bg-green-500" />
+              <Text className="text-xs text-gray-500">SYSTEM ONLINE</Text>
+            </View>
+          </View>
+
+          <View className="h-9 w-9 items-center justify-center rounded-full bg-gray-200">
+            <User size={18} color="#6b7280" />
+          </View>
+        </View>
+
+        {/* Queue Header */}
+        <View className="mt-4 flex-row items-center justify-between">
+          <Text className="text-xs font-semibold text-gray-500">PRIORITY QUEUE (3)</Text>
+
+          <TouchableOpacity>
+            <Text className="text-xs font-semibold text-blue-600">Map View</Text>
+          </TouchableOpacity>
+        </View>
+      </View>
+
+      {/* List */}
+      <FlatList
+        data={CASES}
+        keyExtractor={(i) => i.id}
+        renderItem={({ item }) => <CaseCard item={item} />}
+        contentContainerStyle={{
+          paddingHorizontal: HORIZONTAL_PADDING,
+          paddingTop: 10,
+          paddingBottom: 8,
+        }}
+        showsVerticalScrollIndicator={false}
+      />
+
+      {/* Bottom Scan */}
+      <View className="items-center pb-6 pt-1">
+        <View className="mb-2 h-12 w-12 items-center justify-center rounded-full bg-blue-100">
+          <MapPin size={20} color="#2563eb" />
+        </View>
+        <Text className="text-xs tracking-widest text-gray-400">SCANNING FOR SIGNALS</Text>
+      </View>
+    </SafeAreaView>
+  );
+}
diff --git a/Lifeline-Frontend/app/Helper/Dashboard.tsx b/Lifeline-Frontend/app/Helper/Dashboard.tsx
index 5bda428..b4edbd0 100644
--- a/Lifeline-Frontend/app/Helper/Dashboard.tsx
+++ b/Lifeline-Frontend/app/Helper/Dashboard.tsx
@@ -21,6 +21,9 @@ import { socketService } from "@/src/shared/services";
 import { Ionicons } from "@expo/vector-icons";
 import { playEmergencySound } from "@/src/shared/utils/notification.utils";
 import { useRouter } from "expo-router";
+import * as ExpoLocation from "expo-location";
+
+const HELPER_LOCATION_UPDATE_INTERVAL_MS = 5000;
 
 interface IncomingSOS {
   emergencyId: string;
@@ -38,10 +41,11 @@ export default function HelperDashboard() {
   const dispatch = useDispatch<AppDispatch>();
   const metrics = useSelector((state: RootState) => state.helper.metrics);
   const loading = useSelector((state: RootState) => state.helper.loading);
+  const isAvailable = useSelector((state: RootState) => state.helper.isAvailable);
   const [incomingSOS, setIncomingSOS] = useState<IncomingSOS[]>([]);
   const router = useRouter();
 
-  const userId = user.userId || user.authId;
+  const userId = user.authId || user.userId;
 
   useEffect(() => {
     if (user.userData?.role !== "helper") {
@@ -49,16 +53,11 @@ export default function HelperDashboard() {
     } else if (userId) {
       dispatch(getDashboardMetrics(userId));
     }
-  }, [userId]);
+  }, [dispatch, userId, user.userData?.role]);
 
   useEffect(() => {
-    if (!socketService.isConnected()) {
-      socketService.connect();
-    }
-
-    if (userId) {
-      socketService.registerUser(userId);
-    }
+    if (!socketService.isConnected()) socketService.connect();
+    if (userId) socketService.registerUser(userId, "helper");
 
     // Listen for helper requests (notifications)
     const unsubscribeNotifications = socketService.onNotification((notif) => {
@@ -116,6 +115,68 @@ export default function HelperDashboard() {
     };
   }, [userId, dispatch]);
 
+  useEffect(() => {
+    if (!userId) return;
+    AsyncStorage.setItem("user_id", userId);
+    AsyncStorage.setItem("user_role", "helper");
+  }, [userId]);
+
+  useEffect(() => {
+    if (!userId || !isAvailable) return;
+
+    let isActive = true;
+    let timerId: ReturnType<typeof setInterval> | null = null;
+
+    const reportLocation = async () => {
+      try {
+        if (!isActive) return;
+        if (!socketService.isConnected()) {
+          socketService.connect();
+          return;
+        }
+
+        socketService.registerUser(userId, "helper");
+
+        const loc = await ExpoLocation.getCurrentPositionAsync({
+          accuracy: ExpoLocation.Accuracy.Highest,
+          mayShowUserSettingsDialog: true,
+        });
+
+        socketService.updateLocation({
+          latitude: loc.coords.latitude,
+          longitude: loc.coords.longitude,
+          accuracy: loc.coords.accuracy || undefined,
+          altitude: loc.coords.altitude || undefined,
+          speed: loc.coords.speed || undefined,
+          heading: loc.coords.heading || undefined,
+          userId,
+          role: "helper",
+          timestamp: new Date().toISOString(),
+        });
+      } catch (error) {
+        console.error("Helper foreground location report failed:", error);
+      }
+    };
+
+    const bootstrap = async () => {
+      const { status } = await ExpoLocation.requestForegroundPermissionsAsync();
+      if (status !== "granted") {
+        console.warn("Helper foreground location permission denied.");
+        return;
+      }
+
+      await reportLocation();
+      timerId = setInterval(reportLocation, HELPER_LOCATION_UPDATE_INTERVAL_MS);
+    };
+
+    bootstrap();
+
+    return () => {
+      isActive = false;
+      if (timerId) clearInterval(timerId);
+    };
+  }, [isAvailable, userId]);
+
   return (
     <ScrollView
       className="flex-1 bg-gray-100"
diff --git a/Lifeline-Frontend/app/Helper/EmergencyDetaill.tsx b/Lifeline-Frontend/app/Helper/EmergencyDetaill.tsx
index a0c0272..27b2219 100644
--- a/Lifeline-Frontend/app/Helper/EmergencyDetaill.tsx
+++ b/Lifeline-Frontend/app/Helper/EmergencyDetaill.tsx
@@ -1,17 +1,9 @@
 import React, { useEffect, useState } from "react";
-import {
-  View,
-  Text,
-  TouchableOpacity,
-  ScrollView,
-  Image,
-  ActivityIndicator,
-  Alert,
-} from "react-native";
+import { View, Text, TouchableOpacity, ScrollView, ActivityIndicator, Alert } from "react-native";
 import { useLocalSearchParams, useRouter } from "expo-router";
 import { Ionicons } from "@expo/vector-icons";
 import { socketService } from "@/src/shared/services";
-import api, { API_ENDPOINTS } from "@/src/config/api";
+import { api, API_ENDPOINTS } from "@/src/config/api";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
 
 export default function EmergencyDetail() {
diff --git a/Lifeline-Frontend/app/Helper/Notifications.tsx b/Lifeline-Frontend/app/Helper/Notifications.tsx
index 3073b06..ad300a1 100644
--- a/Lifeline-Frontend/app/Helper/Notifications.tsx
+++ b/Lifeline-Frontend/app/Helper/Notifications.tsx
@@ -1,136 +1,137 @@
-import React, { useEffect, useState } from "react";
+import React, { useCallback, useEffect, useState } from "react";
 import {
-    View,
-    Text,
-    FlatList,
-    TouchableOpacity,
-    ActivityIndicator,
-    RefreshControl,
-    Image,
+  View,
+  Text,
+  FlatList,
+  TouchableOpacity,
+  ActivityIndicator,
+  RefreshControl,
 } from "react-native";
 import { Ionicons } from "@expo/vector-icons";
 import { useRouter } from "expo-router";
 import { useSelector } from "react-redux";
 import { RootState } from "@/src/core/store";
-import api from "@/src/config/api";
+import { api } from "@/src/config/api";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
 
 export default function NotificationsScreen() {
-    const router = useRouter();
-    const userId = useSelector((state: RootState) => state.auth.userId || state.auth.authId);
-    const [notifications, setNotifications] = useState<any[]>([]);
-    const [loading, setLoading] = useState(true);
-    const [refreshing, setRefreshing] = useState(false);
-    const [errorMessage, setErrorMessage] = useState<string | null>(null);
+  const router = useRouter();
+  const userId = useSelector((state: RootState) => state.auth.userId || state.auth.authId);
+  const [notifications, setNotifications] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [refreshing, setRefreshing] = useState(false);
+  const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
-    const fetchNotifications = async () => {
-        if (!userId) {
-            setNotifications([]);
-            setLoading(false);
-            setRefreshing(false);
-            return;
-        }
-        try {
-            setErrorMessage(null);
-            setLoading(true);
-            const response = await api.get(`/api/notifications/v1/user/${userId}`);
-            const data = response?.data?.data;
-            setNotifications(Array.isArray(data) ? data : []);
-        } catch (error: unknown) {
-            const message = getErrorMessage(error, "Failed to fetch notifications");
-            setErrorMessage(message);
-            console.error("Error fetching notifications:", message);
-            setNotifications([]);
-        } finally {
-            setLoading(false);
-            setRefreshing(false);
-        }
-    };
+  const fetchNotifications = useCallback(async () => {
+    if (!userId) {
+      setNotifications([]);
+      setLoading(false);
+      setRefreshing(false);
+      return;
+    }
+    try {
+      setErrorMessage(null);
+      setLoading(true);
+      const response = await api.get(`/api/notifications/v1/user/${userId}`);
+      const data = response?.data?.data;
+      setNotifications(Array.isArray(data) ? data : []);
+    } catch (error: unknown) {
+      const message = getErrorMessage(error, "Failed to fetch notifications");
+      setErrorMessage(message);
+      console.error("Error fetching notifications:", message);
+      setNotifications([]);
+    } finally {
+      setLoading(false);
+      setRefreshing(false);
+    }
+  }, [userId]);
 
-    useEffect(() => {
-        fetchNotifications();
-    }, [userId]);
+  useEffect(() => {
+    fetchNotifications();
+  }, [fetchNotifications]);
 
-    const onRefresh = () => {
-        setRefreshing(true);
-        fetchNotifications();
-    };
+  const onRefresh = () => {
+    setRefreshing(true);
+    fetchNotifications();
+  };
 
-    const renderNotification = ({ item }: { item: any }) => {
-        const isEmergency = item.type === "helper_request" || item.type === "sos_triggered";
-
-        return (
-            <TouchableOpacity
-                className={`flex-row items-start border-b border-gray-100 p-4 ${!item.isRead ? "bg-blue-50/30" : "bg-white"
-                    }`}
-                onPress={() => {
-                    if (item.emergencyId) {
-                        // Navigate to emergency details
-                        router.push(`/Helper/EmergencyDetail?id=${item.emergencyId}` as any);
-                    }
-                }}
-            >
-                <View
-                    className={`h-10 w-10 items-center justify-center rounded-full ${isEmergency ? "bg-red-100" : "bg-blue-100"
-                        }`}
-                >
-                    <Ionicons
-                        name={isEmergency ? "warning" : "notifications"}
-                        size={20}
-                        color={isEmergency ? "#ef4444" : "#2563eb"}
-                    />
-                </View>
-
-                <View className="ml-3 flex-1">
-                    <View className="flex-row items-center justify-between">
-                        <Text className={`font-bold ${!item.isRead ? "text-gray-900" : "text-gray-600"}`}>
-                            {item.title}
-                        </Text>
-                        <Text className="text-[10px] text-gray-400">
-                            {new Date(item.createdAt).toLocaleTimeString([], {
-                                hour: "2-digit",
-                                minute: "2-digit",
-                            })}
-                        </Text>
-                    </View>
-                    <Text className="mt-1 text-sm text-gray-500" numberOfLines={2}>
-                        {item.message}
-                    </Text>
-                </View>
-            </TouchableOpacity>
-        );
-    };
+  const renderNotification = ({ item }: { item: any }) => {
+    const isEmergency = item.type === "helper_request" || item.type === "sos_triggered";
 
     return (
-        <View className="flex-1 bg-white">
-            <View className="flex-row items-center border-b border-gray-100 bg-white px-4 pb-4 pt-12">
-                <TouchableOpacity onPress={() => router.back()} className="-ml-2 p-2">
-                    <Ionicons name="arrow-back" size={24} color="#111827" />
-                </TouchableOpacity>
-                <Text className="ml-2 text-xl font-bold text-gray-900">Notifications</Text>
-            </View>
+      <TouchableOpacity
+        className={`flex-row items-start border-b border-gray-100 p-4 ${
+          !item.isRead ? "bg-blue-50/30" : "bg-white"
+        }`}
+        onPress={() => {
+          if (item.emergencyId) {
+            // Navigate to emergency details
+            router.push(`/Helper/EmergencyDetail?id=${item.emergencyId}` as any);
+          }
+        }}
+      >
+        <View
+          className={`h-10 w-10 items-center justify-center rounded-full ${
+            isEmergency ? "bg-red-100" : "bg-blue-100"
+          }`}
+        >
+          <Ionicons
+            name={isEmergency ? "warning" : "notifications"}
+            size={20}
+            color={isEmergency ? "#ef4444" : "#2563eb"}
+          />
+        </View>
 
-            {loading && !refreshing ? (
-                <View className="flex-1 items-center justify-center">
-                    <ActivityIndicator size="large" color="#2563eb" />
-                </View>
-            ) : (
-                <FlatList
-                    data={notifications}
-                    keyExtractor={(item, index) => item?._id || item?.id || String(index)}
-                    renderItem={renderNotification}
-                    refreshControl={<RefreshControl refreshing={refreshing} onRefresh={onRefresh} />}
-                    ListEmptyComponent={
-                        <View className="flex-1 items-center justify-center pt-20">
-                            <Ionicons name="notifications-off-outline" size={64} color="#d1d5db" />
-                            <Text className="mt-4 px-6 text-center text-lg text-gray-400">
-                                {errorMessage || "No notifications yet"}
-                            </Text>
-                        </View>
-                    }
-                    contentContainerStyle={{ flexGrow: 1 }}
-                />
-            )}
+        <View className="ml-3 flex-1">
+          <View className="flex-row items-center justify-between">
+            <Text className={`font-bold ${!item.isRead ? "text-gray-900" : "text-gray-600"}`}>
+              {item.title}
+            </Text>
+            <Text className="text-[10px] text-gray-400">
+              {new Date(item.createdAt).toLocaleTimeString([], {
+                hour: "2-digit",
+                minute: "2-digit",
+              })}
+            </Text>
+          </View>
+          <Text className="mt-1 text-sm text-gray-500" numberOfLines={2}>
+            {item.message}
+          </Text>
         </View>
+      </TouchableOpacity>
     );
+  };
+
+  return (
+    <View className="flex-1 bg-white">
+      <View className="flex-row items-center border-b border-gray-100 bg-white px-4 pb-4 pt-12">
+        <TouchableOpacity onPress={() => router.back()} className="-ml-2 p-2">
+          <Ionicons name="arrow-back" size={24} color="#111827" />
+        </TouchableOpacity>
+        <Text className="ml-2 text-xl font-bold text-gray-900">Notifications</Text>
+      </View>
+
+      {loading && !refreshing ? (
+        <View className="flex-1 items-center justify-center">
+          <ActivityIndicator size="large" color="#2563eb" />
+        </View>
+      ) : (
+        <FlatList
+          data={notifications}
+          keyExtractor={(item, index) => item?._id || item?.id || String(index)}
+          renderItem={renderNotification}
+          refreshControl={<RefreshControl refreshing={refreshing} onRefresh={onRefresh} />}
+          ListEmptyComponent={
+            <View className="flex-1 items-center justify-center pt-20">
+              <Ionicons name="notifications-off-outline" size={64} color="#d1d5db" />
+              <Text className="mt-4 px-6 text-center text-lg text-gray-400">
+                {errorMessage || "No notifications yet"}
+              </Text>
+            </View>
+          }
+          contentContainerStyle={{ flexGrow: 1 }}
+        />
+      )}
+    </View>
+  );
 }
diff --git a/Lifeline-Frontend/app/Helper/SOSProfile.tsx b/Lifeline-Frontend/app/Helper/SOSProfile.tsx
new file mode 100644
index 0000000..a18c1e0
--- /dev/null
+++ b/Lifeline-Frontend/app/Helper/SOSProfile.tsx
@@ -0,0 +1,12 @@
+import React from "react";
+import { Text, View } from "react-native";
+
+const SOSProfile = () => {
+  return (
+    <View>
+      <Text>SOSProfile</Text>
+    </View>
+  );
+};
+
+export default SOSProfile;
diff --git a/Lifeline-Frontend/app/Helper/_layout.tsx b/Lifeline-Frontend/app/Helper/_layout.tsx
index fb3ddf1..9eeb543 100644
--- a/Lifeline-Frontend/app/Helper/_layout.tsx
+++ b/Lifeline-Frontend/app/Helper/_layout.tsx
@@ -16,6 +16,7 @@ import EmergencyDetail from "./EmergencyDetaill";
 import { router } from "expo-router";
 import { useSelector } from "react-redux";
 import { RootState } from "@/src/core/store";
+import Case from "./Case";
 
 const Tab = createBottomTabNavigator();
 const Stack = createStackNavigator();
@@ -23,7 +24,8 @@ const Stack = createStackNavigator();
 export const CasesStack = () => {
   return (
     <Stack.Navigator screenOptions={{ headerShown: false }}>
-      <Stack.Screen name="CaseDetails" component={CaseDetailsScreen} />
+      <Stack.Screen name="Case" component={Case} />
+      <Stack.Screen name="CaseDetails">{() => <CaseDetailsScreen />}</Stack.Screen>
     </Stack.Navigator>
   );
 };
diff --git a/Lifeline-Frontend/app/Helper/publicProfile[id].tsx b/Lifeline-Frontend/app/Helper/publicProfile[id].tsx
index 2ac5085..6b774ec 100644
--- a/Lifeline-Frontend/app/Helper/publicProfile[id].tsx
+++ b/Lifeline-Frontend/app/Helper/publicProfile[id].tsx
@@ -1,7 +1,7 @@
 import { RootState } from "@/src/core/store";
 import { logout } from "@/src/features/auth/authSlice";
 import AsyncStorage from "@react-native-async-storage/async-storage";
-import { router, useLocalSearchParams, useNavigation } from "expo-router";
+import { router } from "expo-router";
 import React from "react";
 import { Alert, Image, ScrollView, StyleSheet, Text, TouchableOpacity, View } from "react-native";
 import {
@@ -12,9 +12,7 @@ import Ionicons from "react-native-vector-icons/Ionicons";
 import { useDispatch, useSelector } from "react-redux";
 
 export default function PublicProfile() {
-  const navigation = useNavigation();
   const dispatch = useDispatch();
-  const { id } = useLocalSearchParams<{ id: string }>();
   const user = useSelector((state: RootState) => state.auth);
 
   const handleLogout = () => {
diff --git a/Lifeline-Frontend/app/User/Dashboard.tsx b/Lifeline-Frontend/app/User/Dashboard.tsx
index 3df43fe..e04f4df 100644
--- a/Lifeline-Frontend/app/User/Dashboard.tsx
+++ b/Lifeline-Frontend/app/User/Dashboard.tsx
@@ -6,22 +6,25 @@ import {
   Animated,
   Alert,
   Easing,
-  Platform,
   Vibration,
+  AppState,
+  AppStateStatus,
 } from "react-native";
 import Ionicons from "react-native-vector-icons/Ionicons";
 import { useSelector, useDispatch } from "react-redux";
-import { RootState } from "@/src/core/store";
+import { AppDispatch, RootState } from "@/src/core/store";
 import { router } from "expo-router";
 import * as Location from "expo-location";
 import * as TaskManager from "expo-task-manager";
 import AsyncStorage from "@react-native-async-storage/async-storage";
-import { activeSos, deactiveSos } from "@/src/features/SOS/sos.slice";
-import socketService from "@/src/shared/services/socket.service";
+import { clearSOSPendingIntent, triggerSOSActivation } from "@/src/features/SOS/sos.orchestrator";
+import { deactiveSos } from "@/src/features/SOS/sos.slice";
+import { socketService } from "@/src/shared/services/socket.service";
 import { LOCATION_TASK_NAME } from "@/src/shared/tasks/location.task";
+import { LocationEmitSample, stabilizeLocationUpdate } from "@/src/shared/utils/locationStabilizer";
 import { SOCKET_EVENTS } from "@/src/config/socket";
 
-const SOS_HOLD_SECONDS = 4;
+const SOS_HOLD_SECONDS = 3;
 
 const getHoldProgressPercent = (elapsedSeconds: number) => {
   if (elapsedSeconds <= 0) return 0;
@@ -32,7 +35,7 @@ const getHoldProgressPercent = (elapsedSeconds: number) => {
 };
 
 const Dashboard = () => {
-  const dispatch = useDispatch();
+  const dispatch = useDispatch<AppDispatch>();
   const isSOSActive = useSelector((state: RootState) => state.sos.isSOSActive);
   const userData = useSelector((state: RootState) => state.auth.userData);
   const socketAuthId = useSelector((state: RootState) => state.auth.authId || state.auth.userId);
@@ -41,6 +44,11 @@ const Dashboard = () => {
   // Socket Connection & Location Tracking state
   const [isSocketConnected, setIsSocketConnected] = useState(false);
   const locationIntervalRef = useRef<any>(null);
+  const lastForegroundLocationRef = useRef<LocationEmitSample | null>(null);
+  const lastForegroundEmitAtRef = useRef<number>(0);
+  const appStateRef = useRef<AppStateStatus>(AppState.currentState);
+  const trackingSessionStartedAtRef = useRef<number>(0);
+  const foregroundPermissionGrantedRef = useRef(false);
 
   useEffect(() => {
     if (userRole !== "user" && userRole !== undefined) {
@@ -53,6 +61,7 @@ const Dashboard = () => {
     if (socketAuthId) {
       // Store ID for the background task to access
       AsyncStorage.setItem("user_id", socketAuthId);
+      AsyncStorage.setItem("user_role", userRole || "user");
 
       socketService.connect();
       socketService.registerUser(socketAuthId, userRole);
@@ -70,26 +79,38 @@ const Dashboard = () => {
 
   // Handle Real-time & Background Location Updates during SOS
   useEffect(() => {
-    const startLocationReporting = async () => {
-      // 1. Foreground Tracking (Socket-based)
+    let disposed = false;
+
+    const stopForegroundLoop = () => {
       if (locationIntervalRef.current) {
         clearInterval(locationIntervalRef.current);
+        locationIntervalRef.current = null;
+      }
+    };
+
+    const reportLocation = async () => {
+      if (disposed || !socketAuthId) return;
+
+      const now = Date.now();
+      if (now - lastForegroundEmitAtRef.current < 4500) {
+        return;
       }
 
-      const reportLocation = async () => {
-        try {
+      try {
+        if (!foregroundPermissionGrantedRef.current) {
           const { status } = await Location.requestForegroundPermissionsAsync();
           if (status !== "granted") return;
+          foregroundPermissionGrantedRef.current = true;
+        }
 
-          const loc = await Location.getCurrentPositionAsync({ accuracy: Location.Accuracy.High });
+        const loc = await Location.getCurrentPositionAsync({
+          accuracy: Location.Accuracy.BestForNavigation,
+          mayShowUserSettingsDialog: true,
+        });
 
-          // Ensure userId is set in socketService before updating location
-          if (!socketService.getState().userId && socketAuthId) {
-            socketService.registerUser(socketAuthId, userRole);
-          }
-          socketService.emit(SOCKET_EVENTS.LOCATION.UPDATE, {
-            userId: socketAuthId,
-            role: userRole,
+        const decision = stabilizeLocationUpdate({
+          previous: lastForegroundLocationRef.current,
+          incoming: {
             latitude: loc.coords.latitude,
             longitude: loc.coords.longitude,
             accuracy: loc.coords.accuracy || undefined,
@@ -97,87 +118,140 @@ const Dashboard = () => {
             speed: loc.coords.speed || undefined,
             heading: loc.coords.heading || undefined,
             timestamp: new Date().toISOString(),
-          });
+          },
+          minEmitIntervalMs: 4500,
+          lastEmitAtMs: lastForegroundEmitAtRef.current || undefined,
+          trackingStartedAtMs: trackingSessionStartedAtRef.current || undefined,
+          forceEmitAfterMs: 15000,
+          nowMs: now,
+        });
+
+        if (!decision.shouldEmit) {
+          return;
+        }
+
+        lastForegroundLocationRef.current = decision.sample;
+        lastForegroundEmitAtRef.current = now;
+
+        // Ensure userId is set in socketService before updating location
+        if (!socketService.getState().userId && socketAuthId) {
+          socketService.registerUser(socketAuthId, userRole);
+        }
+
+        const sample = decision.sample;
+        socketService.emit(SOCKET_EVENTS.LOCATION.UPDATE, {
+          userId: socketAuthId,
+          role: userRole,
+          latitude: sample.latitude,
+          longitude: sample.longitude,
+          accuracy: sample.accuracy,
+          altitude: sample.altitude,
+          speed: sample.speed,
+          heading: sample.heading,
+          timestamp:
+            typeof sample.timestamp === "string" ? sample.timestamp : new Date().toISOString(),
+        });
+
+        console.log("📍 SOS Location Reported (Foreground):", sample.latitude, sample.longitude);
+      } catch (error) {
+        console.error("Failed to report location:", error);
+      }
+    };
+
+    const startForegroundLoop = () => {
+      stopForegroundLoop();
+      void reportLocation();
+      locationIntervalRef.current = setInterval(() => {
+        void reportLocation();
+      }, 5000);
+    };
+
+    const startBackgroundTracking = async () => {
+      try {
+        // Check for foreground perm first
+        const { status: fgStatus } = await Location.requestForegroundPermissionsAsync();
+        if (fgStatus !== "granted") {
+          Alert.alert("Permission Required", "This feature needs location permission to work.");
+          return;
+        }
 
-          console.log(
-            "📍 SOS Location Reported (Foreground):",
-            loc.coords.latitude,
-            loc.coords.longitude
+        // Request background perm (Always)
+        const { status: bgStatus } = await Location.requestBackgroundPermissionsAsync();
+        if (bgStatus !== "granted") {
+          console.warn(
+            "Background location permission denied. Tracking will only work in foreground."
           );
-        } catch (error) {
-          console.error("Failed to report location:", error);
         }
-      };
 
-      // 2. Background Tracking (Task-based)
-      const startBackgroundTracking = async () => {
-        try {
-          // Check for foreground perm first
-          const { status: fgStatus } = await Location.requestForegroundPermissionsAsync();
-          if (fgStatus !== "granted") {
-            Alert.alert("Permission Required", "This feature needs location permission to work.");
-            return;
-          }
-
-          // Request background perm (Always)
-          const { status: bgStatus } = await Location.requestBackgroundPermissionsAsync();
-          if (bgStatus !== "granted") {
-            console.warn(
-              "Background location permission denied. Tracking will only work in foreground."
-            );
-          }
-
-          const isTaskRegistered = await TaskManager.isTaskRegisteredAsync(LOCATION_TASK_NAME);
-          if (!isTaskRegistered) {
-            await Location.startLocationUpdatesAsync(LOCATION_TASK_NAME, {
-              accuracy: Location.Accuracy.High,
-              timeInterval: 5000,
-              distanceInterval: 1,
-              foregroundService: {
-                notificationTitle: "LifeLine SOS Active",
-                notificationBody: "Reporting your location to emergency services.",
-                notificationColor: "#FF0000",
-              },
-            });
-            console.log("📍 Background Location Task Started");
-          }
-        } catch (error) {
-          console.error("Background tracking setup error:", error);
+        const isTaskRegistered = await TaskManager.isTaskRegisteredAsync(LOCATION_TASK_NAME);
+        if (!isTaskRegistered) {
+          await Location.startLocationUpdatesAsync(LOCATION_TASK_NAME, {
+            accuracy: Location.Accuracy.BestForNavigation,
+            timeInterval: 5000,
+            distanceInterval: 2,
+            foregroundService: {
+              notificationTitle: "LifeLine SOS Active",
+              notificationBody: "Reporting your location to emergency services.",
+              notificationColor: "#FF0000",
+            },
+          });
+          console.log("📍 Background Location Task Started");
         }
-      };
+      } catch (error) {
+        console.error("Background tracking setup error:", error);
+      }
+    };
 
-      const stopBackgroundTracking = async () => {
-        try {
-          const isTaskRegistered = await TaskManager.isTaskRegisteredAsync(LOCATION_TASK_NAME);
-          if (isTaskRegistered) {
-            await Location.stopLocationUpdatesAsync(LOCATION_TASK_NAME);
-            console.log("📍 Background Location Task Stopped");
-          }
-        } catch (error) {
-          console.error("Background tracking stop error:", error);
+    const stopBackgroundTracking = async () => {
+      try {
+        const isTaskRegistered = await TaskManager.isTaskRegisteredAsync(LOCATION_TASK_NAME);
+        if (isTaskRegistered) {
+          await Location.stopLocationUpdatesAsync(LOCATION_TASK_NAME);
+          console.log("📍 Background Location Task Stopped");
         }
-      };
+      } catch (error) {
+        console.error("Background tracking stop error:", error);
+      }
+    };
+
+    const applyTrackingMode = async (state: AppStateStatus) => {
+      if (!isSOSActive) {
+        stopForegroundLoop();
+        lastForegroundLocationRef.current = null;
+        lastForegroundEmitAtRef.current = 0;
+        trackingSessionStartedAtRef.current = 0;
+        foregroundPermissionGrantedRef.current = false;
+        await stopBackgroundTracking();
+        return;
+      }
+
+      if (!trackingSessionStartedAtRef.current) {
+        trackingSessionStartedAtRef.current = Date.now();
+      }
 
-      if (isSOSActive) {
-        // Start both foreground and background tracking
-        reportLocation();
-        locationIntervalRef.current = setInterval(reportLocation, 5000);
-        startBackgroundTracking();
+      const isForeground = state === "active";
+      if (isForeground) {
+        await stopBackgroundTracking();
+        startForegroundLoop();
       } else {
-        if (locationIntervalRef.current) {
-          clearInterval(locationIntervalRef.current);
-          locationIntervalRef.current = null;
-        }
-        stopBackgroundTracking();
+        stopForegroundLoop();
+        await startBackgroundTracking();
       }
     };
 
-    startLocationReporting();
+    void applyTrackingMode(appStateRef.current);
+
+    const appStateSubscription = AppState.addEventListener("change", (nextState) => {
+      appStateRef.current = nextState;
+      void applyTrackingMode(nextState);
+    });
 
     return () => {
-      if (locationIntervalRef.current) {
-        clearInterval(locationIntervalRef.current);
-      }
+      disposed = true;
+      appStateSubscription.remove();
+      stopForegroundLoop();
+      foregroundPermissionGrantedRef.current = false;
+      void stopBackgroundTracking();
     };
   }, [isSOSActive, socketAuthId, userRole]);
 
@@ -260,7 +334,7 @@ const Dashboard = () => {
       if (anim) anim.stop();
       Vibration.cancel();
     };
-  }, [isSOSActive]);
+  }, [isSOSActive, pulseAnim, rippleAnim]);
 
   // Breathing outer ring while user is holding the SOS button
   useEffect(() => {
@@ -336,8 +410,14 @@ const Dashboard = () => {
         animateRingProgress(100, 260);
         if (isSOSActive) {
           dispatch(deactiveSos());
+          void clearSOSPendingIntent();
         } else {
-          dispatch(activeSos());
+          void triggerSOSActivation({
+            dispatch,
+            isSOSActive,
+            source: "dashboard_hold",
+            openScreen: true,
+          });
         }
         Vibration.vibrate(1000);
       }
@@ -423,7 +503,9 @@ const Dashboard = () => {
                   className="absolute h-72 w-72 rounded-full border-2 border-red-500/30"
                   style={{
                     transform: [
-                      { scale: rippleAnim.interpolate({ inputRange: [0, 1], outputRange: [1, 2] }) },
+                      {
+                        scale: rippleAnim.interpolate({ inputRange: [0, 1], outputRange: [1, 2] }),
+                      },
                     ],
                     opacity: rippleAnim.interpolate({ inputRange: [0, 1], outputRange: [0.8, 0] }),
                   }}
diff --git a/Lifeline-Frontend/app/User/Helper/HelperRequest.tsx b/Lifeline-Frontend/app/User/Helper/HelperRequest.tsx
index 9b43f08..ee6a154 100644
--- a/Lifeline-Frontend/app/User/Helper/HelperRequest.tsx
+++ b/Lifeline-Frontend/app/User/Helper/HelperRequest.tsx
@@ -1,16 +1,3 @@
-// If location sharing is needed for helpers/NGOs, add socketService.updateLocation usage where appropriate (e.g., on accept, etc.)
-import socketService from "@/src/shared/services/socket.service";
-
-// Example: Add location update on Accept (inside Accept button handler)
-// ...existing code...
-// onPress={() => {
-//   socketService.updateLocation({
-//     latitude: /* helper's latitude */,
-//     longitude: /* helper's longitude */,
-//     // ...other fields
-//   });
-//   // ...other accept logic...
-// }}
 import React, { useState } from "react";
 import { View, Text, TouchableOpacity, Image, ScrollView } from "react-native";
 import Ionicons from "react-native-vector-icons/Ionicons";
diff --git a/Lifeline-Frontend/app/User/IncomeUserSOS.tsx b/Lifeline-Frontend/app/User/IncomeUserSOS.tsx
index fbe39cf..1aa39c6 100644
--- a/Lifeline-Frontend/app/User/IncomeUserSOS.tsx
+++ b/Lifeline-Frontend/app/User/IncomeUserSOS.tsx
@@ -1,11 +1,9 @@
 // src/screens/IncomeUserSOS.jsx
-import { View, Text, FlatList, TouchableOpacity } from "react-native";
 
-import { Map } from "lucide-react-native";
+import { View, Text, FlatList, TouchableOpacity } from "react-native";
+import { Map, Activity } from "lucide-react-native";
 import SOSCard from "@/src/features/Helper/Case/Components/SOSCard";
 
-// src/data/sosData.js
-
 type SOSItem = {
   id: string;
   name: string;
@@ -62,34 +60,51 @@ export const sosList: SOSItem[] = [
 
 export default function IncomeUserSOS() {
   return (
-    <View className="flex-1 bg-gray-50 px-4 pt-12">
-      {/* Header */}
-      <View className="mb-4">
-        <Text className="text-xl font-bold text-gray-900">Incoming SOS</Text>
+    <View className="flex-1 bg-gray-100 px-4 pt-12">
+      {/* ===== Header ===== */}
+      <View className="mb-6 flex-row items-center justify-between">
+        <View>
+          <Text className="text-2xl font-bold text-gray-900">Incoming SOS</Text>
 
-        <View className="mt-1 flex-row items-center">
-          <View className="mr-2 h-2 w-2 rounded-full bg-green-500" />
-          <Text className="text-xs font-semibold text-green-600">SYSTEM ONLINE</Text>
+          <View className="mt-1 flex-row items-center">
+            <Activity size={14} color="#16a34a" />
+            <Text className="ml-1 text-xs font-semibold text-green-600">SYSTEM ONLINE</Text>
+          </View>
         </View>
+
+        <TouchableOpacity className="flex-row items-center rounded-lg bg-blue-600 px-3 py-2">
+          <Map size={16} color="white" />
+          <Text className="ml-2 text-sm font-semibold text-white">Map View</Text>
+        </TouchableOpacity>
       </View>
 
-      {/* Queue Header */}
-      <View className="mb-3 flex-row items-center justify-between">
-        <Text className="font-semibold text-gray-500">PRIORITY QUEUE ({sosList.length})</Text>
+      {/* ===== Queue Info Card ===== */}
+      <View className="mb-5 rounded-xl bg-white p-4 shadow-sm">
+        <View className="flex-row items-center justify-between">
+          <View>
+            <Text className="text-xs font-semibold text-gray-500">PRIORITY QUEUE</Text>
 
-        <TouchableOpacity className="flex-row items-center">
-          <Map size={16} color="#2563eb" />
-          <Text className="ml-1 text-sm font-semibold text-blue-600">Map View</Text>
-        </TouchableOpacity>
+            <Text className="text-lg font-bold text-gray-900">
+              {sosList.length} Active Requests
+            </Text>
+          </View>
+
+          <View className="rounded-lg bg-red-100 px-3 py-1">
+            <Text className="text-xs font-semibold text-red-600">LIVE</Text>
+          </View>
+        </View>
       </View>
 
-      {/* SOS List */}
+      {/* ===== SOS LIST ===== */}
+
       <FlatList
         data={sosList}
         keyExtractor={(item) => item.id}
         renderItem={({ item }) => <SOSCard item={item} />}
         showsVerticalScrollIndicator={false}
-        contentContainerStyle={{ paddingBottom: 20 }}
+        contentContainerStyle={{
+          paddingBottom: 40,
+        }}
       />
     </View>
   );
diff --git a/Lifeline-Frontend/app/User/Nearby.tsx b/Lifeline-Frontend/app/User/Nearby.tsx
index c381b10..0c037b7 100644
--- a/Lifeline-Frontend/app/User/Nearby.tsx
+++ b/Lifeline-Frontend/app/User/Nearby.tsx
@@ -13,7 +13,7 @@ import {
   View,
 } from "react-native";
 import Ionicons from "react-native-vector-icons/Ionicons";
-import api, { API_ENDPOINTS } from "@/src/config/api";
+import { api, API_ENDPOINTS } from "@/src/config/api";
 import { router } from "expo-router";
 import { useSelector } from "react-redux";
 import { RootState } from "@/src/core/store";
@@ -258,7 +258,9 @@ const NearbyScreen: React.FC = () => {
 
       const ngosData = asArray<any>(ngosResponse?.data?.data);
       const normalizedNgos = ngosData.map((n, index) => {
-        const coordinates = Array.isArray(n?.location?.coordinates) ? n.location.coordinates : [0, 0];
+        const coordinates = Array.isArray(n?.location?.coordinates)
+          ? n.location.coordinates
+          : [0, 0];
 
         return {
           id: n?._id || n?.id || `ngo-${index}`,
diff --git a/Lifeline-Frontend/app/User/Profile/AccountDetails.tsx b/Lifeline-Frontend/app/User/Profile/AccountDetails.tsx
index 1f7a4a4..818212c 100644
--- a/Lifeline-Frontend/app/User/Profile/AccountDetails.tsx
+++ b/Lifeline-Frontend/app/User/Profile/AccountDetails.tsx
@@ -1,5 +1,3 @@
-import { StyleSheet, Text, View } from "react-native";
-import React from "react";
 import AccountDetails from "@/src/features/auth/User/Pages/AccountDetails";
 
 const UserProfile = () => {
diff --git a/Lifeline-Frontend/app/User/Profile/SavedAddressScreen.tsx b/Lifeline-Frontend/app/User/Profile/SavedAddressScreen.tsx
index 6cb4f31..c68dfe2 100644
--- a/Lifeline-Frontend/app/User/Profile/SavedAddressScreen.tsx
+++ b/Lifeline-Frontend/app/User/Profile/SavedAddressScreen.tsx
@@ -1,12 +1,11 @@
 import UniversalMap from "@/src/features/auth/screens/UniversalMap";
 import React, { useState } from "react";
-import { View, Text, ScrollView, TextInput, TouchableOpacity, Image } from "react-native";
+import { Alert, View, Text, ScrollView, TextInput, TouchableOpacity } from "react-native";
 import * as Location from "expo-location";
 import Ionicons from "react-native-vector-icons/Ionicons";
 
 const SavedAddressScreen = () => {
   const [location, setLocation] = useState<any>(null);
-  const [errorMsg, setErrorMsg] = useState<string | null>(null);
   const [address, setAddress] = useState({
     street: "123 Maple Avenue",
     city: "Springfield",
@@ -18,7 +17,7 @@ const SavedAddressScreen = () => {
   const getLocation = async () => {
     let { status } = await Location.requestForegroundPermissionsAsync();
     if (status !== "granted") {
-      setErrorMsg("Permission to access location was denied");
+      Alert.alert("Permission Required", "Permission to access location was denied");
       return;
     }
 
@@ -111,15 +110,3 @@ const InputField = ({ label, value }: any) => (
     />
   </View>
 );
-
-const TextAreaField = ({ label, value }: any) => (
-  <View className="mb-4">
-    {label && <Text className="mb-1 text-xs text-gray-400">{label}</Text>}
-    <TextInput
-      value={value}
-      editable={false}
-      multiline
-      className="min-h-[70px] rounded-lg bg-gray-100 px-3 py-3 text-gray-900"
-    />
-  </View>
-);
diff --git a/Lifeline-Frontend/app/_layout.tsx b/Lifeline-Frontend/app/_layout.tsx
index 5c9ff1d..3bf17cc 100644
--- a/Lifeline-Frontend/app/_layout.tsx
+++ b/Lifeline-Frontend/app/_layout.tsx
@@ -4,11 +4,13 @@ import { ThemeProvider } from "@/src/theme/ThemeContext";
 import { Slot } from "expo-router";
 import Providers from "@/src/core/Providers";
 import AppErrorBoundary from "@/src/core/AppErrorBoundary";
+import SOSRuntimeBootstrapper from "@/src/features/SOS/SOSRuntimeBootstrapper";
 export default function RootLayout() {
   return (
     <Providers>
       <ThemeProvider>
         <AppErrorBoundary>
+          <SOSRuntimeBootstrapper />
           <Slot />
         </AppErrorBoundary>
       </ThemeProvider>
diff --git a/Lifeline-Frontend/plugins/withPowerButtonSOS.js b/Lifeline-Frontend/plugins/withPowerButtonSOS.js
new file mode 100644
index 0000000..a05e891
--- /dev/null
+++ b/Lifeline-Frontend/plugins/withPowerButtonSOS.js
@@ -0,0 +1,521 @@
+const fs = require("fs");
+const path = require("path");
+const {
+  createRunOncePlugin,
+  withAndroidManifest,
+  withDangerousMod,
+} = require("expo/config-plugins");
+
+const PLUGIN_NAME = "with-power-button-sos";
+const PLUGIN_VERSION = "1.0.0";
+
+const SERVICE_CLASS_NAME = ".sos.PowerButtonMonitorService";
+const RECEIVER_CLASS_NAME = ".sos.PowerButtonBootReceiver";
+
+const REQUIRED_PERMISSIONS = [
+  "android.permission.RECEIVE_BOOT_COMPLETED",
+  "android.permission.WAKE_LOCK",
+  "android.permission.FOREGROUND_SERVICE",
+  "android.permission.FOREGROUND_SERVICE_DATA_SYNC",
+];
+
+const ensurePermission = (androidManifest, permissionName) => {
+  const permissions = androidManifest.manifest["uses-permission"] || [];
+  const hasPermission = permissions.some((item) => item?.$?.["android:name"] === permissionName);
+
+  if (!hasPermission) {
+    permissions.push({
+      $: {
+        "android:name": permissionName,
+      },
+    });
+  }
+
+  androidManifest.manifest["uses-permission"] = permissions;
+};
+
+const ensureService = (application) => {
+  application.service = application.service || [];
+  const hasService = application.service.some(
+    (service) => service?.$?.["android:name"] === SERVICE_CLASS_NAME
+  );
+
+  if (hasService) return;
+
+  application.service.push({
+    $: {
+      "android:name": SERVICE_CLASS_NAME,
+      "android:enabled": "true",
+      "android:exported": "false",
+      "android:stopWithTask": "false",
+      "android:foregroundServiceType": "dataSync",
+    },
+  });
+};
+
+const ensureBootReceiver = (application) => {
+  application.receiver = application.receiver || [];
+  const hasReceiver = application.receiver.some(
+    (receiver) => receiver?.$?.["android:name"] === RECEIVER_CLASS_NAME
+  );
+
+  if (hasReceiver) return;
+
+  application.receiver.push({
+    $: {
+      "android:name": RECEIVER_CLASS_NAME,
+      "android:enabled": "true",
+      "android:exported": "true",
+    },
+    "intent-filter": [
+      {
+        action: [
+          { $: { "android:name": "android.intent.action.BOOT_COMPLETED" } },
+          { $: { "android:name": "android.intent.action.LOCKED_BOOT_COMPLETED" } },
+          { $: { "android:name": "android.intent.action.MY_PACKAGE_REPLACED" } },
+        ],
+      },
+    ],
+  });
+};
+
+const withPowerButtonSOSManifest = (config) =>
+  withAndroidManifest(config, (modConfig) => {
+    const androidManifest = modConfig.modResults;
+    const application = androidManifest?.manifest?.application?.[0];
+
+    if (!application) {
+      return modConfig;
+    }
+
+    REQUIRED_PERMISSIONS.forEach((permission) => {
+      ensurePermission(androidManifest, permission);
+    });
+
+    ensureService(application);
+    ensureBootReceiver(application);
+
+    return modConfig;
+  });
+
+const findMainApplicationFile = (androidProjectRoot) => {
+  const javaRoot = path.join(androidProjectRoot, "app", "src", "main", "java");
+  if (!fs.existsSync(javaRoot)) return null;
+
+  const stack = [javaRoot];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolute = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absolute);
+      } else if (
+        entry.isFile() &&
+        (entry.name === "MainApplication.kt" || entry.name === "MainApplication.java")
+      ) {
+        return absolute;
+      }
+    }
+  }
+
+  return null;
+};
+
+const readPackageNameFromMainApplication = (mainApplicationPath) => {
+  if (!mainApplicationPath || !fs.existsSync(mainApplicationPath)) return null;
+  const contents = fs.readFileSync(mainApplicationPath, "utf8");
+  const packageMatch = contents.match(/^\s*package\s+([a-zA-Z0-9_.]+)\s*$/m);
+  return packageMatch?.[1] || null;
+};
+
+const writeFile = (targetPath, contents) => {
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.writeFileSync(targetPath, contents, "utf8");
+};
+
+const getBridgeTemplate = (packageName) => `package ${packageName}.sos
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import java.lang.ref.WeakReference
+
+object PowerButtonSOSBridge {
+  private var reactContextRef: WeakReference<ReactApplicationContext>? = null
+
+  fun setReactContext(reactContext: ReactApplicationContext) {
+    reactContextRef = WeakReference(reactContext)
+  }
+
+  fun emitEvent(eventName: String, payload: WritableMap? = null) {
+    val reactContext = reactContextRef?.get() ?: return
+    if (!reactContext.hasActiveCatalystInstance()) return
+
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+      .emit(eventName, payload)
+  }
+}
+`;
+
+const getModuleTemplate = (packageName) => `package ${packageName}.sos
+
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+class PowerButtonSOSModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  companion object {
+    const val NAME = "PowerButtonSOSModule"
+    const val PREFS_NAME = "lifeline_power_sos_prefs"
+    const val PREF_KEY_ENABLED = "enabled"
+    const val PREF_KEY_TRIGGER_COUNT = "trigger_count"
+  }
+
+  init {
+    PowerButtonSOSBridge.setReactContext(reactContext)
+  }
+
+  override fun getName(): String = NAME
+
+  @ReactMethod
+  fun setPressTriggerThreshold(pressCount: Int) {
+    val safeCount = pressCount.coerceAtLeast(2)
+    prefs().edit().putInt(PREF_KEY_TRIGGER_COUNT, safeCount).apply()
+  }
+
+  @ReactMethod
+  fun startListening(pressCount: Int?) {
+    pressCount?.let { setPressTriggerThreshold(it) }
+    prefs().edit().putBoolean(PREF_KEY_ENABLED, true).apply()
+    startMonitorService()
+  }
+
+  @ReactMethod
+  fun stopListening() {
+    prefs().edit().putBoolean(PREF_KEY_ENABLED, false).apply()
+    reactContext.stopService(Intent(reactContext, PowerButtonMonitorService::class.java))
+  }
+
+  private fun startMonitorService() {
+    val serviceIntent = Intent(reactContext, PowerButtonMonitorService::class.java)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      reactContext.startForegroundService(serviceIntent)
+    } else {
+      reactContext.startService(serviceIntent)
+    }
+  }
+
+  private fun prefs() = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+}
+`;
+
+const getPackageTemplate = (packageName) => `package ${packageName}.sos
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class PowerButtonSOSPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(PowerButtonSOSModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}
+`;
+
+const getServiceTemplate = (packageName) => `package ${packageName}.sos
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.Service
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.Uri
+import android.os.Build
+import android.os.IBinder
+import com.facebook.react.bridge.WritableNativeMap
+import java.util.ArrayDeque
+
+class PowerButtonMonitorService : Service() {
+  companion object {
+    private const val CHANNEL_ID = "lifeline_power_button_channel"
+    private const val CHANNEL_NAME = "LifeLine SOS Power Monitor"
+    private const val NOTIFICATION_ID = 20260301
+    private const val PRESS_WINDOW_MS = 7000L
+  }
+
+  private val powerButtonPresses = ArrayDeque<Long>()
+
+  private val screenReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+      val action = intent?.action ?: return
+      if (action == Intent.ACTION_SCREEN_OFF || action == Intent.ACTION_SCREEN_ON) {
+        registerPowerButtonPress()
+      }
+    }
+  }
+
+  override fun onCreate() {
+    super.onCreate()
+    startInForeground()
+    registerScreenReceiver()
+  }
+
+  override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+    if (!isEnabled()) {
+      stopSelf()
+      return START_NOT_STICKY
+    }
+    return START_STICKY
+  }
+
+  override fun onDestroy() {
+    runCatching { unregisterReceiver(screenReceiver) }
+    powerButtonPresses.clear()
+    super.onDestroy()
+  }
+
+  override fun onBind(intent: Intent?): IBinder? = null
+
+  private fun registerScreenReceiver() {
+    val filter = IntentFilter().apply {
+      addAction(Intent.ACTION_SCREEN_ON)
+      addAction(Intent.ACTION_SCREEN_OFF)
+    }
+    registerReceiver(screenReceiver, filter)
+  }
+
+  private fun registerPowerButtonPress() {
+    val now = System.currentTimeMillis()
+
+    while (powerButtonPresses.isNotEmpty() && now - powerButtonPresses.first() > PRESS_WINDOW_MS) {
+      powerButtonPresses.removeFirst()
+    }
+
+    powerButtonPresses.addLast(now)
+    val count = powerButtonPresses.size
+
+    emitPerPressEvents(count)
+
+    val triggerCount = triggerCount()
+    if (count >= triggerCount) {
+      powerButtonPresses.clear()
+      emitTriggerEvents()
+      launchSOSScreen()
+    }
+  }
+
+  private fun emitPerPressEvents(count: Int) {
+    val payload = WritableNativeMap().apply { putInt("count", count) }
+    PowerButtonSOSBridge.emitEvent("PowerButtonPressed", payload)
+    PowerButtonSOSBridge.emitEvent("powerButtonPressed", payload)
+    PowerButtonSOSBridge.emitEvent("power_button_pressed", payload)
+  }
+
+  private fun emitTriggerEvents() {
+    PowerButtonSOSBridge.emitEvent("PowerButtonFivePressSOS", null)
+    PowerButtonSOSBridge.emitEvent("powerButtonFivePressSOS", null)
+    PowerButtonSOSBridge.emitEvent("power_button_5_press_sos", null)
+  }
+
+  private fun launchSOSScreen() {
+    val deepLinkIntent = Intent(
+      Intent.ACTION_VIEW,
+      Uri.parse("lifeline://sos/trigger?source=power_button_5_press")
+    ).apply {
+      addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+      addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
+    }
+    runCatching { startActivity(deepLinkIntent) }
+  }
+
+  private fun triggerCount(): Int {
+    return prefs().getInt(PowerButtonSOSModule.PREF_KEY_TRIGGER_COUNT, 5).coerceAtLeast(2)
+  }
+
+  private fun isEnabled(): Boolean {
+    return prefs().getBoolean(PowerButtonSOSModule.PREF_KEY_ENABLED, false)
+  }
+
+  private fun prefs() = getSharedPreferences(PowerButtonSOSModule.PREFS_NAME, Context.MODE_PRIVATE)
+
+  private fun startInForeground() {
+    val notificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val channel = NotificationChannel(
+        CHANNEL_ID,
+        CHANNEL_NAME,
+        NotificationManager.IMPORTANCE_LOW
+      )
+      notificationManager.createNotificationChannel(channel)
+    }
+
+    val notificationBuilder =
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        Notification.Builder(this, CHANNEL_ID)
+      } else {
+        Notification.Builder(this)
+      }
+
+    val notification = notificationBuilder
+      .setContentTitle("LifeLine SOS Monitor Active")
+      .setContentText("Press power button 5 times quickly to trigger SOS.")
+      .setSmallIcon(android.R.drawable.ic_dialog_alert)
+      .setOngoing(true)
+      .build()
+
+    startForeground(NOTIFICATION_ID, notification)
+  }
+}
+`;
+
+const getBootReceiverTemplate = (packageName) => `package ${packageName}.sos
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+
+class PowerButtonBootReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context, intent: Intent?) {
+    val action = intent?.action ?: return
+    val validAction =
+      action == Intent.ACTION_BOOT_COMPLETED ||
+      action == Intent.ACTION_LOCKED_BOOT_COMPLETED ||
+      action == Intent.ACTION_MY_PACKAGE_REPLACED
+
+    if (!validAction) return
+
+    val prefs = context.getSharedPreferences(PowerButtonSOSModule.PREFS_NAME, Context.MODE_PRIVATE)
+    val enabled = prefs.getBoolean(PowerButtonSOSModule.PREF_KEY_ENABLED, false)
+    if (!enabled) return
+
+    val serviceIntent = Intent(context, PowerButtonMonitorService::class.java)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      context.startForegroundService(serviceIntent)
+    } else {
+      context.startService(serviceIntent)
+    }
+  }
+}
+`;
+
+const patchMainApplicationFile = (mainApplicationPath, packageName) => {
+  if (!mainApplicationPath || !fs.existsSync(mainApplicationPath)) return;
+  let contents = fs.readFileSync(mainApplicationPath, "utf8");
+
+  const isKotlin = mainApplicationPath.endsWith(".kt");
+  if (isKotlin) {
+    const importLine = `import ${packageName}.sos.PowerButtonSOSPackage`;
+    if (!contents.includes(importLine)) {
+      const packageDeclarationMatch = contents.match(/^\s*package\s+[^\n]+\n/m);
+      if (packageDeclarationMatch && packageDeclarationMatch.index !== undefined) {
+        const insertAt = packageDeclarationMatch.index + packageDeclarationMatch[0].length;
+        contents = `${contents.slice(0, insertAt)}${importLine}\n${contents.slice(insertAt)}`;
+      } else {
+        contents = `${importLine}\n${contents}`;
+      }
+    }
+
+    if (!contents.includes("packages.add(PowerButtonSOSPackage())")) {
+      if (contents.includes("val packages = PackageList(this).packages")) {
+        contents = contents.replace(
+          "val packages = PackageList(this).packages",
+          "val packages = PackageList(this).packages\n      packages.add(PowerButtonSOSPackage())"
+        );
+      } else {
+        const shortGetPackagesPattern =
+          /override\s+fun\s+getPackages\(\)\s*:\s*List<ReactPackage>\s*=\s*PackageList\(this\)\.packages/;
+        if (shortGetPackagesPattern.test(contents)) {
+          contents = contents.replace(
+            shortGetPackagesPattern,
+            "override fun getPackages(): List<ReactPackage> {\n      val packages = PackageList(this).packages\n      packages.add(PowerButtonSOSPackage())\n      return packages\n    }"
+          );
+        }
+      }
+    }
+  } else {
+    const importLine = `import ${packageName}.sos.PowerButtonSOSPackage;`;
+    if (!contents.includes(importLine)) {
+      contents = contents.replace(
+        /import com\.facebook\.react\.ReactPackage;\n/,
+        `import com.facebook.react.ReactPackage;\n${importLine}\n`
+      );
+    }
+
+    if (!contents.includes("packages.add(new PowerButtonSOSPackage());")) {
+      contents = contents.replace(
+        "List<ReactPackage> packages = new PackageList(this).getPackages();",
+        "List<ReactPackage> packages = new PackageList(this).getPackages();\n      packages.add(new PowerButtonSOSPackage());"
+      );
+    }
+  }
+
+  fs.writeFileSync(mainApplicationPath, contents, "utf8");
+};
+
+const withPowerButtonSOSNativeCode = (config) =>
+  withDangerousMod(config, [
+    "android",
+    async (modConfig) => {
+      const androidProjectRoot = modConfig.modRequest.platformProjectRoot;
+      const mainApplicationPath = findMainApplicationFile(androidProjectRoot);
+      const packageName = readPackageNameFromMainApplication(mainApplicationPath);
+
+      if (!mainApplicationPath || !packageName) {
+        console.warn(
+          `[${PLUGIN_NAME}] Could not resolve MainApplication or package name. Native SOS module files were not generated.`
+        );
+        return modConfig;
+      }
+
+      const packagePath = packageName.split(".").join(path.sep);
+      const sosDir = path.join(
+        androidProjectRoot,
+        "app",
+        "src",
+        "main",
+        "java",
+        packagePath,
+        "sos"
+      );
+
+      writeFile(path.join(sosDir, "PowerButtonSOSBridge.kt"), getBridgeTemplate(packageName));
+      writeFile(path.join(sosDir, "PowerButtonSOSModule.kt"), getModuleTemplate(packageName));
+      writeFile(path.join(sosDir, "PowerButtonSOSPackage.kt"), getPackageTemplate(packageName));
+      writeFile(path.join(sosDir, "PowerButtonMonitorService.kt"), getServiceTemplate(packageName));
+      writeFile(
+        path.join(sosDir, "PowerButtonBootReceiver.kt"),
+        getBootReceiverTemplate(packageName)
+      );
+
+      patchMainApplicationFile(mainApplicationPath, packageName);
+
+      return modConfig;
+    },
+  ]);
+
+const withPowerButtonSOS = (config) => {
+  config = withPowerButtonSOSManifest(config);
+  config = withPowerButtonSOSNativeCode(config);
+  return config;
+};
+
+module.exports = createRunOncePlugin(withPowerButtonSOS, PLUGIN_NAME, PLUGIN_VERSION);
diff --git a/Lifeline-Frontend/src/ai/sarvam-stt.ts b/Lifeline-Frontend/src/ai/sarvam-stt.ts
index 670ab79..92559c6 100644
--- a/Lifeline-Frontend/src/ai/sarvam-stt.ts
+++ b/Lifeline-Frontend/src/ai/sarvam-stt.ts
@@ -1,5 +1,4 @@
 import { Audio } from "expo-av";
-import * as FileSystem from "expo-file-system";
 import axios from "axios";
 
 const SARVAM_API_KEY = process.env.SARVAM_API_KEY;
diff --git a/Lifeline-Frontend/src/config/api.ts b/Lifeline-Frontend/src/config/api.ts
index 7892c93..0d043ab 100644
--- a/Lifeline-Frontend/src/config/api.ts
+++ b/Lifeline-Frontend/src/config/api.ts
@@ -11,16 +11,20 @@ import { getErrorMessage } from "../shared/utils/error.utils";
 
 // Lazy store getter to avoid circular dependency:
 // store.ts → emergencySlice → config/api.ts → store.ts
-let _store: any = null;
-const getStore = () => {
-  if (!_store) {
-    _store = require("../core/store").store;
+type AppStore = (typeof import("../core/store"))["store"];
+let _store: AppStore | null = null;
+const getStore = (): AppStore | null => {
+  if (_store) {
+    return _store;
   }
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  _store = require("../core/store").store as AppStore;
   return _store;
 };
 
 // Base URL from environment
-const API_URL = process.env.EXPO_PUBLIC_API_URL?.replace(/\/+$/, "") || "http://localhost:5000";
+const rawApiUrl = process.env.EXPO_PUBLIC_API_URL;
+const API_URL = rawApiUrl ? rawApiUrl.trim().replace(/\/+$/, "") : "http://localhost:5000";
 
 /**
  * Axios instance with default configuration
@@ -31,6 +35,7 @@ export const api = axios.create({
   withCredentials: true,
   headers: {
     "Content-Type": "application/json",
+    "bypass-tunnel-reminder": "1",
   },
 });
 
@@ -86,10 +91,12 @@ export const API_ENDPOINTS = {
   AUTH: {
     LOGIN: "/api/auth/v1/login",
     REGISTER: "/api/auth/v1/create/user/auth",
-    CHECK_EMAIL: "/api/auth/v1/check-email",
-    VERIFY_EMAIL: "/api/auth/v1/verify-email",
+    CHECK_EMAIL: (email: string) => `/api/auth/v1/check-email/${email}`,
+    VERIFY_EMAIL: (token: string) => `/api/auth/v1/verify-email/${token}`,
     FORGOT_PASSWORD: "/api/auth/v1/forgot-password",
     RESET_PASSWORD: "/api/auth/v1/reset-password",
+    PROFILE: "/api/auth/v1/profile",
+    UPDATE_PROFILE: "/api/auth/v1/profile",
   },
 
   // Emergency
@@ -97,12 +104,19 @@ export const API_ENDPOINTS = {
     BASE: "/api/emergency",
     SOS: "/api/emergency/sos",
     GET_BY_ID: (id: string) => `/api/emergency/${id}`,
+    PROFILE: (id: string) => `/api/emergency/${id}/profile`,
     USER_EMERGENCIES: "/api/emergency/user/me",
     NEARBY: "/api/emergency/nearby/search",
     ACCEPT: (id: string) => `/api/emergency/${id}/accept`,
     ARRIVED: (id: string) => `/api/emergency/${id}/arrived`,
     RESOLVE: (id: string) => `/api/emergency/${id}/resolve`,
     CANCEL: (id: string) => `/api/emergency/${id}`,
+    // New Payment Features
+    PAYMENT: {
+      APPROVE: (id: string) => `/api/emergency/${id}/approve`,
+      VERIFY_OTP: (id: string) => `/api/emergency/${id}/verify-otp`,
+    },
+    ASSIGNED: "/api/emergency/assigned/me",
   },
 
   // AI Triage
@@ -124,30 +138,39 @@ export const API_ENDPOINTS = {
 
   // Notifications
   NOTIFICATIONS: {
-    LIST: "/api/notifications",
-    MARK_READ: (id: string) => `/api/notifications/${id}/read`,
-    MARK_ALL_READ: "/api/notifications/read-all",
-    UNREAD_COUNT: "/api/notifications/unread-count",
+    BASE: "/api/notifications/v1",
+    LIST: "/api/notifications/v1",
+    MARK_READ: (id: string) => `/api/notifications/v1/${id}/read`,
+    MARK_ALL_READ: "/api/notifications/v1/read-all",
+    UNREAD_COUNT: "/api/notifications/v1/unread-count",
   },
 
   // User
   USER: {
-    PROFILE: "/api/user/profile",
-    UPDATE: "/api/user/update",
-    MEDICAL_INFO: "/api/user/medical-info",
+    // Deprecated: Use AUTH.PROFILE instead
+    PROFILE: "/api/auth/v1/profile",
+    UPDATE: "/api/auth/v1/profile",
+    MEDICAL_INFO: "/api/medical/v1/profile/me",
   },
 
   // Helper
   HELPER: {
-    PROFILE: "/api/helper/profile",
-    AVAILABILITY: "/api/helper/availability",
-    NEARBY: "/api/helper/nearby",
+    PROFILE: "/api/helpers/v1/profile/me",
+    AVAILABILITY: (id: string) => `/api/helpers/v1/${id}/availability`,
+    NEARBY: "/api/locations/v1/nearby/helpers",
+    STATS: (id: string) => `/api/helpers/v1/stats/${id}`,
   },
 
   // NGO
   NGO: {
     NEARBY: "/api/ngo/v1/nearby",
   },
+
+  // Payments
+  PAYMENTS: {
+    CREATE: "/api/payments",
+    RELEASE: (id: string) => `/api/payments/${id}/release`,
+  },
 } as const;
 
 export default api;
diff --git a/Lifeline-Frontend/src/config/socket.ts b/Lifeline-Frontend/src/config/socket.ts
index cb05fc1..f54a046 100644
--- a/Lifeline-Frontend/src/config/socket.ts
+++ b/Lifeline-Frontend/src/config/socket.ts
@@ -7,7 +7,8 @@
 import { io, Socket } from "socket.io-client";
 
 // Socket URL from environment
-const SOCKET_URL = process.env.EXPO_PUBLIC_API_URL?.replace(/\/+$/, "") || "http://localhost:5000";
+const rawSocketUrl = process.env.EXPO_PUBLIC_API_URL;
+const SOCKET_URL = rawSocketUrl ? rawSocketUrl.trim().replace(/\/+$/, "") : "http://localhost:5000";
 
 /**
  * Socket.IO Event Constants
diff --git a/Lifeline-Frontend/src/core/Navigation.tsx b/Lifeline-Frontend/src/core/Navigation.tsx
index 3245ba3..6c8e1fc 100644
--- a/Lifeline-Frontend/src/core/Navigation.tsx
+++ b/Lifeline-Frontend/src/core/Navigation.tsx
@@ -1,5 +1,3 @@
-import React from "react";
-
 export function Navigation() {
   return null;
 }
diff --git a/Lifeline-Frontend/src/core/Providers.tsx b/Lifeline-Frontend/src/core/Providers.tsx
index 2196d17..fb46c3e 100644
--- a/Lifeline-Frontend/src/core/Providers.tsx
+++ b/Lifeline-Frontend/src/core/Providers.tsx
@@ -1,9 +1,7 @@
 import React from "react";
-import { Provider } from "react-redux";
+import { Provider, useDispatch } from "react-redux";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { store } from "../core/store";
-import { useDispatch } from "react-redux";
-import { AppDispatch } from "./store";
+import { store, AppDispatch } from "../core/store";
 import { hydrateAuth } from "../features/auth/authSlice";
 
 // Create a client
diff --git a/Lifeline-Frontend/src/features/Helper/Case/Components/SOSCard.tsx b/Lifeline-Frontend/src/features/Helper/Case/Components/SOSCard.tsx
index cba1f97..1a5d8e9 100644
--- a/Lifeline-Frontend/src/features/Helper/Case/Components/SOSCard.tsx
+++ b/Lifeline-Frontend/src/features/Helper/Case/Components/SOSCard.tsx
@@ -1,61 +1,95 @@
 // src/components/SOSCard.jsx
+
 import { View, Text, TouchableOpacity, Image } from "react-native";
-import { AlertTriangle, MessageCircle, MapPin } from "lucide-react-native";
+import { AlertTriangle, MessageCircle, MapPin, Clock } from "lucide-react-native";
 
-// src/utils/priorityStyles.js
+// Priority UI styles
 export const priorityStyles = {
-  CRITICAL: "bg-red-100 text-red-600",
-  MEDIUM: "bg-orange-100 text-orange-600",
-  MODERATE: "bg-yellow-100 text-yellow-600",
-  SAFETY: "bg-green-100 text-green-600",
+  CRITICAL: {
+    badge: "bg-red-100",
+    text: "text-red-600",
+    border: "border-red-300",
+  },
+  MEDIUM: {
+    badge: "bg-orange-100",
+    text: "text-orange-600",
+    border: "border-orange-300",
+  },
+  MODERATE: {
+    badge: "bg-yellow-100",
+    text: "text-yellow-600",
+    border: "border-yellow-300",
+  },
+  SAFETY: {
+    badge: "bg-green-100",
+    text: "text-green-600",
+    border: "border-green-300",
+  },
 };
 
 type SOSItem = {
   name: string;
   issue: string;
   eta: string;
+  time?: string;
+  distance?: string;
   priority: "CRITICAL" | "MEDIUM" | "MODERATE" | "SAFETY";
 };
 
 export default function SOSCard({ item }: { item: SOSItem }) {
+  const style = priorityStyles[item.priority];
+
   return (
-    <View className="mb-4 rounded-2xl border border-gray-200 bg-white p-4">
-      {/* Top */}
+    <View className="mb-4 rounded-2xl bg-white p-4 shadow-sm">
+      {/* TOP SECTION */}
       <View className="flex-row justify-between">
         <View className="flex-1 flex-row">
+          {/* Avatar */}
           <Image
             source={{ uri: "https://i.pravatar.cc/100" }}
             className="mr-3 h-12 w-12 rounded-full"
           />
 
+          {/* User Info */}
           <View className="flex-1">
             {/* Name + Priority */}
-            <View className="mb-0.5 flex-row items-center">
-              <Text className="mr-2 font-semibold text-gray-900">{item.name}</Text>
+            <View className="mb-1 flex-row items-center">
+              <Text className="mr-2 text-base font-semibold text-gray-900">{item.name}</Text>
 
-              <View className={`rounded px-2 py-0.5 ${priorityStyles[item.priority]}`}>
-                <Text className="text-[10px] font-semibold">{item.priority}</Text>
+              <View className={`rounded-full px-2 py-0.5 ${style.badge}`}>
+                <Text className={`text-[10px] font-semibold ${style.text}`}>{item.priority}</Text>
               </View>
             </View>
 
             {/* Issue */}
             <Text className="text-sm text-gray-700">{item.issue}</Text>
 
-            {/* Distance row */}
-            <View className="mt-1 flex-row items-center">
-              <MapPin size={12} color="#9ca3af" />
-              <Text className="ml-1 text-xs text-gray-400">{item.eta}</Text>
+            {/* Location + Time */}
+            <View className="mt-2 flex-row items-center">
+              <View className="mr-4 flex-row items-center">
+                <MapPin size={12} color="#9ca3af" />
+                <Text className="ml-1 text-xs text-gray-500">{item.eta}</Text>
+              </View>
+
+              {item.time && (
+                <View className="flex-row items-center">
+                  <Clock size={12} color="#9ca3af" />
+                  <Text className="ml-1 text-xs text-gray-500">{item.time}</Text>
+                </View>
+              )}
             </View>
           </View>
         </View>
 
-        {/* Alert */}
-        <View className="h-9 w-9 items-center justify-center rounded-full border border-orange-300">
-          <AlertTriangle size={18} color="#f97316" />
+        {/* Alert Icon */}
+        <View
+          className={`h-10 w-10 items-center justify-center rounded-full border ${style.border}`}
+        >
+          <AlertTriangle size={18} color="#ef4444" />
         </View>
       </View>
 
-      {/* Actions Row */}
+      {/* ACTION BUTTONS */}
       <View className="mt-4 flex-row items-center">
         {/* Reject */}
         <TouchableOpacity className="mr-2 flex-1 items-center rounded-lg border border-red-400 py-2">
@@ -67,7 +101,7 @@ export default function SOSCard({ item }: { item: SOSItem }) {
           <Text className="font-semibold text-white">Accept</Text>
         </TouchableOpacity>
 
-        {/* Message Icon */}
+        {/* Message */}
         <TouchableOpacity className="h-10 w-10 items-center justify-center rounded-lg border border-gray-300">
           <MessageCircle size={18} color="#6b7280" />
         </TouchableOpacity>
diff --git a/Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/StatusToggle.tsx b/Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/StatusToggle.tsx
index f0f381d..03a1d80 100644
--- a/Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/StatusToggle.tsx
+++ b/Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/StatusToggle.tsx
@@ -6,18 +6,18 @@ import { RootState, AppDispatch } from "@/src/core/store";
 import { useBackgroundLocation } from "@/src/shared/hooks/useBackgroundLocation";
 import AsyncStorage from "@react-native-async-storage/async-storage";
 
-export function StatusToggle({}) {
+export function StatusToggle() {
   const isAvailable = useSelector((state: RootState) => state.helper.isAvailable);
   let [status, setStatus] = useState<boolean>(isAvailable);
   const dispatch = useDispatch<AppDispatch>();
   const { startBackgroundTracking, stopBackgroundTracking } = useBackgroundLocation();
-  const userId = useSelector((state: RootState) => state.auth.userId || state.auth.authId);
+  const userId = useSelector((state: RootState) => state.auth.authId || state.auth.userId);
 
   useEffect(() => {
     if (userId) {
       dispatch(checkAvailability(userId));
     }
-  }, [userId]);
+  }, [dispatch, userId]);
 
   useEffect(() => {
     setStatus(isAvailable);
@@ -25,17 +25,22 @@ export function StatusToggle({}) {
 
   useEffect(() => {
     const syncStatus = async () => {
+      if (userId) {
+        await AsyncStorage.setItem("user_id", userId);
+      }
+      await AsyncStorage.setItem("user_role", "helper");
       await AsyncStorage.setItem("is_available", status ? "true" : "false");
       if (status) {
-        startBackgroundTracking();
+        await startBackgroundTracking();
       } else {
-        stopBackgroundTracking();
+        await stopBackgroundTracking();
       }
     };
     syncStatus();
-  }, [status, startBackgroundTracking, stopBackgroundTracking]);
+  }, [status, startBackgroundTracking, stopBackgroundTracking, userId]);
 
   const onChange = async (newStatus: boolean) => {
+    if (newStatus === status) return;
     setStatus(newStatus);
     await AsyncStorage.setItem("is_available", newStatus ? "true" : "false");
     if (userId) {
diff --git a/Lifeline-Frontend/src/features/Helper/helperSlice.ts b/Lifeline-Frontend/src/features/Helper/helperSlice.ts
index 0d70960..e49006f 100644
--- a/Lifeline-Frontend/src/features/Helper/helperSlice.ts
+++ b/Lifeline-Frontend/src/features/Helper/helperSlice.ts
@@ -1,5 +1,5 @@
 import { createSlice, createAsyncThunk, PayloadAction } from "@reduxjs/toolkit";
-import api from "@/src/config/api";
+import { api, API_ENDPOINTS } from "@/src/config/api";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
 
 export interface DashboardMetrics {
@@ -29,14 +29,13 @@ const initialState: HelperState = {
   error: null,
 };
 
-const API_URL = process.env.EXPO_PUBLIC_API_URL?.replace(/\/+$/, "");
-const API_BASE_URL = `${API_URL}/api/helpers/v1`;
+const HELPER_BASE = "/api/helpers/v1";
 
 export const checkAvailability = createAsyncThunk(
   "helper/checkAvailability",
   async (id: string, { rejectWithValue }) => {
     try {
-      const response = await api.get(`${API_BASE_URL}/checkCurrentAvailability/${id}`);
+      const response = await api.get(`${HELPER_BASE}/checkCurrentAvailability/${id}`);
       return response.data;
     } catch (error: any) {
       console.error("Error checking availability:", error);
@@ -49,7 +48,7 @@ export const updateAvailability = createAsyncThunk(
   "helper/updateAvailability",
   async ({ isAvailable, id }: { isAvailable: boolean; id: string }, { rejectWithValue }) => {
     try {
-      const response = await api.patch(`${API_BASE_URL}/${id}/availability`, {
+      const response = await api.patch(API_ENDPOINTS.HELPER.AVAILABILITY(id), {
         isAvailable,
       });
       return response.data;
@@ -64,7 +63,7 @@ export const getDashboardMetrics = createAsyncThunk(
   "helper/getDashboardMetrics",
   async (id: string, { rejectWithValue }) => {
     try {
-      const response = await api.get(`${API_BASE_URL}/${id}/dashboard`);
+      const response = await api.get(`${HELPER_BASE}/${id}/dashboard`);
       return response.data;
     } catch (error: any) {
       console.error("Error fetching dashboard metrics:", error);
@@ -73,6 +72,19 @@ export const getDashboardMetrics = createAsyncThunk(
   }
 );
 
+export const getHelperStats = createAsyncThunk(
+  "helper/getStats",
+  async (id: string, { rejectWithValue }) => {
+    try {
+      const response = await api.get(API_ENDPOINTS.HELPER.STATS(id));
+      return response.data;
+    } catch (error: any) {
+      console.error("Error fetching helper stats:", error);
+      return rejectWithValue(getErrorMessage(error, "Failed to fetch stats"));
+    }
+  }
+);
+
 const helperSlice = createSlice({
   name: "helper",
   initialState,
@@ -113,6 +125,22 @@ const helperSlice = createSlice({
       state.loading = false;
       state.error = action.payload as string;
     });
+
+    builder.addCase(getHelperStats.pending, (state) => {
+      state.loading = true;
+      state.error = null;
+    });
+    builder.addCase(
+      getHelperStats.fulfilled,
+      (state, action: PayloadAction<{ data: DashboardMetrics }>) => {
+        state.loading = false;
+        state.metrics = action.payload.data;
+      }
+    );
+    builder.addCase(getHelperStats.rejected, (state, action) => {
+      state.loading = false;
+      state.error = action.payload as string;
+    });
   },
 });
 
diff --git a/Lifeline-Frontend/src/features/SOS/SOSRuntimeBootstrapper.tsx b/Lifeline-Frontend/src/features/SOS/SOSRuntimeBootstrapper.tsx
new file mode 100644
index 0000000..5bbcea0
--- /dev/null
+++ b/Lifeline-Frontend/src/features/SOS/SOSRuntimeBootstrapper.tsx
@@ -0,0 +1,213 @@
+import React from "react";
+import { AppState, DeviceEventEmitter, Linking, NativeModules, Platform } from "react-native";
+import * as ExpoLinking from "expo-linking";
+import { usePathname } from "expo-router";
+import { useDispatch, useSelector } from "react-redux";
+import { AppDispatch, RootState } from "@/src/core/store";
+import {
+  clearSOSPendingIntent,
+  getSOSPendingIntent,
+  isSOSPendingIntentFresh,
+  isSOSScreenPath,
+  normalizeSOSTriggerSource,
+  persistSOSPendingIntent,
+  SOSTriggerSource,
+  triggerSOSActivation,
+} from "./sos.orchestrator";
+
+const POWER_BUTTON_PRESS_TRIGGER_COUNT = 5;
+const POWER_BUTTON_PRESS_WINDOW_MS = 7000;
+
+const resolveSOSTriggerSourceFromUrl = (url: string): SOSTriggerSource | null => {
+  const normalizedUrl = url.toLowerCase();
+  if (!normalizedUrl.includes("sos/trigger")) {
+    return null;
+  }
+
+  const parsedUrl = ExpoLinking.parse(url);
+  const sourceQuery = parsedUrl.queryParams?.source;
+
+  if (typeof sourceQuery === "string") {
+    return normalizeSOSTriggerSource(sourceQuery);
+  }
+
+  return "deeplink";
+};
+
+export default function SOSRuntimeBootstrapper() {
+  const dispatch = useDispatch<AppDispatch>();
+  const pathname = usePathname();
+
+  const { isAuthenticated, isHydrated } = useSelector((state: RootState) => state.auth);
+  const isSOSActive = useSelector((state: RootState) => state.sos.isSOSActive);
+
+  const isRecoveringRef = React.useRef(false);
+  const powerPressTimestampsRef = React.useRef<number[]>([]);
+
+  const canHandleSOS = isHydrated && isAuthenticated;
+  const shouldOpenSOSScreen = !isSOSScreenPath(pathname);
+
+  const handleTrigger = React.useCallback(
+    async (source: SOSTriggerSource) => {
+      if (!canHandleSOS) {
+        await persistSOSPendingIntent(source);
+        return;
+      }
+
+      await triggerSOSActivation({
+        dispatch,
+        isSOSActive,
+        source,
+        openScreen: shouldOpenSOSScreen,
+      });
+
+      await clearSOSPendingIntent();
+    },
+    [canHandleSOS, dispatch, isSOSActive, shouldOpenSOSScreen]
+  );
+
+  const recoverPendingSOSIntent = React.useCallback(async () => {
+    if (!canHandleSOS || isRecoveringRef.current) {
+      return;
+    }
+
+    isRecoveringRef.current = true;
+    try {
+      const pendingIntent = await getSOSPendingIntent();
+      if (!pendingIntent) return;
+
+      if (!isSOSPendingIntentFresh(pendingIntent)) {
+        await clearSOSPendingIntent();
+        return;
+      }
+
+      await triggerSOSActivation({
+        dispatch,
+        isSOSActive,
+        source: pendingIntent.source || "app_resume_recovery",
+        openScreen: shouldOpenSOSScreen,
+        persistIntent: false,
+      });
+
+      await clearSOSPendingIntent();
+    } finally {
+      isRecoveringRef.current = false;
+    }
+  }, [canHandleSOS, dispatch, isSOSActive, shouldOpenSOSScreen]);
+
+  const registerPowerButtonPress = React.useCallback(() => {
+    const now = Date.now();
+    const recentPresses = [...powerPressTimestampsRef.current, now].filter(
+      (ts) => now - ts <= POWER_BUTTON_PRESS_WINDOW_MS
+    );
+
+    powerPressTimestampsRef.current = recentPresses;
+
+    if (recentPresses.length >= POWER_BUTTON_PRESS_TRIGGER_COUNT) {
+      powerPressTimestampsRef.current = [];
+      void handleTrigger("power_button_5_press");
+    }
+  }, [handleTrigger]);
+
+  React.useEffect(() => {
+    void recoverPendingSOSIntent();
+  }, [recoverPendingSOSIntent]);
+
+  React.useEffect(() => {
+    const appStateSubscription = AppState.addEventListener("change", (nextState) => {
+      if (nextState === "active") {
+        void recoverPendingSOSIntent();
+      }
+    });
+
+    return () => {
+      appStateSubscription.remove();
+    };
+  }, [recoverPendingSOSIntent]);
+
+  React.useEffect(() => {
+    const consumeUrlIfSOSTrigger = async (url: string | null) => {
+      if (!url) return;
+      const source = resolveSOSTriggerSourceFromUrl(url);
+      if (!source) return;
+      await handleTrigger(source);
+    };
+
+    void Linking.getInitialURL().then((url) => {
+      void consumeUrlIfSOSTrigger(url);
+    });
+
+    const linkSubscription = Linking.addEventListener("url", (event) => {
+      void consumeUrlIfSOSTrigger(event.url);
+    });
+
+    return () => {
+      linkSubscription.remove();
+    };
+  }, [handleTrigger]);
+
+  React.useEffect(() => {
+    if (Platform.OS !== "android") {
+      return;
+    }
+
+    const nativePowerModule = (NativeModules.PowerButtonSOSModule ||
+      NativeModules.PowerButtonSOS ||
+      NativeModules.LifeLinePowerButtonSOS) as
+      | {
+          setPressTriggerThreshold?: (pressCount: number) => void;
+          startListening?: (pressCount?: number) => void;
+          stopListening?: () => void;
+        }
+      | undefined;
+
+    if (!nativePowerModule) {
+      return;
+    }
+
+    const handleNativePowerTrigger = () => {
+      void handleTrigger("power_button_native");
+    };
+    const handleNativePowerFivePress = () => {
+      void handleTrigger("power_button_5_press");
+    };
+    const handleNativePowerPressSignal = (event?: { count?: number }) => {
+      if (typeof event?.count === "number" && event.count >= POWER_BUTTON_PRESS_TRIGGER_COUNT) {
+        void handleTrigger("power_button_5_press");
+        return;
+      }
+      registerPowerButtonPress();
+    };
+
+    // Native Android module can either emit a dedicated 5-press event or per-press events.
+    const listeners = [
+      DeviceEventEmitter.addListener("PowerButtonHoldSOS", handleNativePowerTrigger),
+      DeviceEventEmitter.addListener("powerButtonHoldSOS", handleNativePowerTrigger),
+      DeviceEventEmitter.addListener("power_button_hold_sos", handleNativePowerTrigger),
+      DeviceEventEmitter.addListener("PowerButtonFivePressSOS", handleNativePowerFivePress),
+      DeviceEventEmitter.addListener("powerButtonFivePressSOS", handleNativePowerFivePress),
+      DeviceEventEmitter.addListener("power_button_5_press_sos", handleNativePowerFivePress),
+      DeviceEventEmitter.addListener("PowerButtonPressed", handleNativePowerPressSignal),
+      DeviceEventEmitter.addListener("powerButtonPressed", handleNativePowerPressSignal),
+      DeviceEventEmitter.addListener("power_button_pressed", handleNativePowerPressSignal),
+    ];
+
+    try {
+      nativePowerModule.setPressTriggerThreshold?.(POWER_BUTTON_PRESS_TRIGGER_COUNT);
+      nativePowerModule.startListening?.(POWER_BUTTON_PRESS_TRIGGER_COUNT);
+    } catch (error) {
+      console.warn("[SOS] Native power listener start failed:", error);
+    }
+
+    return () => {
+      listeners.forEach((listener) => listener.remove());
+      try {
+        nativePowerModule.stopListening?.();
+      } catch (error) {
+        console.warn("[SOS] Native power listener stop failed:", error);
+      }
+    };
+  }, [handleTrigger, registerPowerButtonPress]);
+
+  return null;
+}
diff --git a/Lifeline-Frontend/src/features/SOS/sos.orchestrator.ts b/Lifeline-Frontend/src/features/SOS/sos.orchestrator.ts
new file mode 100644
index 0000000..03cd5aa
--- /dev/null
+++ b/Lifeline-Frontend/src/features/SOS/sos.orchestrator.ts
@@ -0,0 +1,140 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import { router } from "expo-router";
+import { AppDispatch } from "@/src/core/store";
+import { activeSos, deactiveSos } from "./sos.slice";
+
+const SOS_PENDING_INTENT_STORAGE_KEY = "lifeline_sos_pending_intent_v1";
+const SOS_PENDING_INTENT_MAX_AGE_MS = 10 * 60 * 1000;
+const SOS_TRIGGER_COOLDOWN_MS = 1500;
+
+export const SOS_SCREEN_PATH = "/(global)/SOSActiveAIScreen";
+
+let lastTriggerAtMs = 0;
+
+export type SOSTriggerSource =
+  | "dashboard_hold"
+  | "power_button_native"
+  | "power_button_5_press"
+  | "notification_action"
+  | "deeplink"
+  | "app_resume_recovery"
+  | "unknown";
+
+export type SOSPendingIntent = {
+  source: SOSTriggerSource;
+  createdAt: string;
+};
+
+const SOURCE_LOOKUP: Record<string, SOSTriggerSource> = {
+  dashboard_hold: "dashboard_hold",
+  power_button_native: "power_button_native",
+  power_button_5_press: "power_button_5_press",
+  notification_action: "notification_action",
+  deeplink: "deeplink",
+  app_resume_recovery: "app_resume_recovery",
+  unknown: "unknown",
+};
+
+export const normalizeSOSTriggerSource = (source: string | null | undefined): SOSTriggerSource => {
+  if (!source) return "unknown";
+  return SOURCE_LOOKUP[source] || "unknown";
+};
+
+export const isSOSScreenPath = (pathname: string | null | undefined): boolean => {
+  return typeof pathname === "string" && pathname.toLowerCase().includes("sosactiveaiscreen");
+};
+
+export const openSOSScreen = () => {
+  try {
+    router.push(SOS_SCREEN_PATH);
+  } catch (error) {
+    console.warn("[SOS] Navigation to SOS screen failed:", error);
+  }
+};
+
+export const persistSOSPendingIntent = async (
+  source: SOSTriggerSource,
+  createdAt: Date = new Date()
+) => {
+  try {
+    const payload: SOSPendingIntent = {
+      source,
+      createdAt: createdAt.toISOString(),
+    };
+    await AsyncStorage.setItem(SOS_PENDING_INTENT_STORAGE_KEY, JSON.stringify(payload));
+  } catch (error) {
+    console.warn("[SOS] Failed to persist pending intent:", error);
+  }
+};
+
+export const getSOSPendingIntent = async (): Promise<SOSPendingIntent | null> => {
+  try {
+    const raw = await AsyncStorage.getItem(SOS_PENDING_INTENT_STORAGE_KEY);
+    if (!raw) return null;
+
+    const parsed = JSON.parse(raw) as Partial<SOSPendingIntent> | null;
+    if (!parsed || typeof parsed !== "object") return null;
+    if (typeof parsed.createdAt !== "string") return null;
+
+    return {
+      source: normalizeSOSTriggerSource(parsed.source),
+      createdAt: parsed.createdAt,
+    };
+  } catch (error) {
+    console.warn("[SOS] Failed to read pending intent:", error);
+    return null;
+  }
+};
+
+export const clearSOSPendingIntent = async () => {
+  try {
+    await AsyncStorage.removeItem(SOS_PENDING_INTENT_STORAGE_KEY);
+  } catch (error) {
+    console.warn("[SOS] Failed to clear pending intent:", error);
+  }
+};
+
+export const isSOSPendingIntentFresh = (pendingIntent: SOSPendingIntent, now = Date.now()) => {
+  const createdAtMs = Date.parse(pendingIntent.createdAt);
+  if (Number.isNaN(createdAtMs)) return false;
+  return now - createdAtMs <= SOS_PENDING_INTENT_MAX_AGE_MS;
+};
+
+type TriggerSOSActivationInput = {
+  dispatch: AppDispatch;
+  isSOSActive: boolean;
+  source: SOSTriggerSource;
+  openScreen?: boolean;
+  persistIntent?: boolean;
+};
+
+export const triggerSOSActivation = async ({
+  dispatch,
+  isSOSActive,
+  source,
+  openScreen = true,
+  persistIntent = true,
+}: TriggerSOSActivationInput) => {
+  const now = Date.now();
+
+  if (persistIntent) {
+    await persistSOSPendingIntent(source, new Date(now));
+  }
+
+  const inCooldown = now - lastTriggerAtMs < SOS_TRIGGER_COOLDOWN_MS;
+  if (!isSOSActive || !inCooldown) {
+    if (!isSOSActive) {
+      dispatch(activeSos());
+    }
+    lastTriggerAtMs = now;
+  }
+
+  if (openScreen) {
+    openSOSScreen();
+  }
+};
+
+export const deactivateSOSFlow = async (dispatch: AppDispatch) => {
+  dispatch(deactiveSos());
+  await clearSOSPendingIntent();
+};
diff --git a/Lifeline-Frontend/src/features/User/Component/UserNav.tsx b/Lifeline-Frontend/src/features/User/Component/UserNav.tsx
index c350f95..8fc3d64 100644
--- a/Lifeline-Frontend/src/features/User/Component/UserNav.tsx
+++ b/Lifeline-Frontend/src/features/User/Component/UserNav.tsx
@@ -69,7 +69,7 @@ const UserNav = () => {
           isAuthenticated ? (
             <TouchableOpacity
               onPress={handleDashboard}
-              className="rounded-lg bg-blue-500 px-4 py-2 flex-row items-center"
+              className="flex-row items-center rounded-lg bg-blue-500 px-4 py-2"
             >
               <AntDesign name="dashboard" size={20} color="white" style={{ marginRight: 6 }} />
               <Text className="font-semibold text-white">Dashboard</Text>
diff --git a/Lifeline-Frontend/src/features/auth/authSlice.ts b/Lifeline-Frontend/src/features/auth/authSlice.ts
index b34504d..2a5f2cb 100644
--- a/Lifeline-Frontend/src/features/auth/authSlice.ts
+++ b/Lifeline-Frontend/src/features/auth/authSlice.ts
@@ -1,6 +1,6 @@
 import { createSlice, createAsyncThunk, PayloadAction } from "@reduxjs/toolkit";
 import AsyncStorage from "@react-native-async-storage/async-storage";
-import api from "@/src/config/api";
+import { api } from "@/src/config/api";
 import {
   AUTH_STORAGE_KEY,
   USER_ID_STORAGE_KEY,
@@ -72,20 +72,17 @@ const clearAuthStorage = () => {
   AsyncStorage.multiRemove([AUTH_STORAGE_KEY, USER_ID_STORAGE_KEY]);
 };
 
-export const hydrateAuth = createAsyncThunk(
-  "auth/hydrate",
-  async (_, { rejectWithValue }) => {
-    try {
-      const raw = await AsyncStorage.getItem(AUTH_STORAGE_KEY);
-      if (!raw) return null;
+export const hydrateAuth = createAsyncThunk("auth/hydrate", async (_, { rejectWithValue }) => {
+  try {
+    const raw = await AsyncStorage.getItem(AUTH_STORAGE_KEY);
+    if (!raw) return null;
 
-      const parsed = JSON.parse(raw);
-      return parsed;
-    } catch (error: any) {
-      return rejectWithValue(error?.message || "Failed to restore auth session");
-    }
+    const parsed = JSON.parse(raw);
+    return parsed;
+  } catch (error: any) {
+    return rejectWithValue(error?.message || "Failed to restore auth session");
   }
-);
+});
 
 // Async thunks
 export const checkEmailExists = createAsyncThunk(
@@ -118,11 +115,8 @@ export const createUser = createAsyncThunk(
   "auth/createUser",
   async (userData: FormData, { rejectWithValue }) => {
     try {
-      const response = await api.post(`${API_BASE_URL}/create/user/auth`, userData, {
-        headers: {
-          "Content-Type": "multipart/form-data",
-        },
-      });
+      // Let Axios/React Native set multipart boundary automatically for FormData.
+      const response = await api.post(`${API_BASE_URL}/create/user/auth`, userData);
       console.log("Create User Response:", response.data); // Debug log
       return response.data.data;
     } catch (error: any) {
@@ -146,16 +140,20 @@ export const updateUserProfile = createAsyncThunk(
         return rejectWithValue("User not authenticated");
       }
 
-      const response = await api.patch(`${API_BASE_URL}/profile`, {
-        ...updatedData,
-        // Keep compatibility with backend auth schema
-        name: updatedData.fullName,
-        phoneNumber: updatedData.mobileNumber,
-      }, {
-        headers: {
-          Authorization: `Bearer ${token}`,
+      const response = await api.patch(
+        `${API_BASE_URL}/profile`,
+        {
+          ...updatedData,
+          // Keep compatibility with backend auth schema
+          name: updatedData.fullName,
+          phoneNumber: updatedData.mobileNumber,
         },
-      });
+        {
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        }
+      );
       return response.data.data;
     } catch (error: any) {
       return rejectWithValue(getErrorMessage(error, "Failed to update profile"));
diff --git a/Lifeline-Frontend/src/features/auth/locationSlice.ts b/Lifeline-Frontend/src/features/auth/locationSlice.ts
index 2f2e3ea..e892daf 100644
--- a/Lifeline-Frontend/src/features/auth/locationSlice.ts
+++ b/Lifeline-Frontend/src/features/auth/locationSlice.ts
@@ -1,5 +1,5 @@
 import { createSlice, createAsyncThunk, PayloadAction } from "@reduxjs/toolkit";
-import api from "@/src/config/api";
+import { api } from "@/src/config/api";
 import { resolveAuthToken } from "@/src/features/auth/authSession.utils";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
 
diff --git a/Lifeline-Frontend/src/features/auth/medicalSlice.ts b/Lifeline-Frontend/src/features/auth/medicalSlice.ts
index 7804f43..305035c 100644
--- a/Lifeline-Frontend/src/features/auth/medicalSlice.ts
+++ b/Lifeline-Frontend/src/features/auth/medicalSlice.ts
@@ -1,5 +1,5 @@
 import { createSlice, createAsyncThunk, PayloadAction } from "@reduxjs/toolkit";
-import api from "@/src/config/api";
+import { api } from "@/src/config/api";
 import { resolveAuthToken } from "@/src/features/auth/authSession.utils";
 import { getErrorMessage } from "@/src/shared/utils/error.utils";
 
@@ -165,24 +165,21 @@ export const getContacts = createAsyncThunk<
   contactParams[],
   string,
   { rejectValue: string; state: any }
->(
-  "medical/getContacts",
-  async (medicalId, { rejectWithValue, getState }) => {
-    try {
-      const token = await resolveAuthToken(getState() as any);
-      if (!token) {
-        return rejectWithValue("Authentication token missing. Please login again.");
-      }
-
-      const response = await api.get(`${API_BASE_URL}/${medicalId}/emergency-contacts`, {
-        headers: getAuthHeaders(token),
-      });
-      return response.data.data;
-    } catch (error: any) {
-      return rejectWithValue(getErrorMessage(error, "Failed to fetch contacts"));
+>("medical/getContacts", async (medicalId, { rejectWithValue, getState }) => {
+  try {
+    const token = await resolveAuthToken(getState() as any);
+    if (!token) {
+      return rejectWithValue("Authentication token missing. Please login again.");
     }
+
+    const response = await api.get(`${API_BASE_URL}/${medicalId}/emergency-contacts`, {
+      headers: getAuthHeaders(token),
+    });
+    return response.data.data;
+  } catch (error: any) {
+    return rejectWithValue(getErrorMessage(error, "Failed to fetch contacts"));
   }
-);
+});
 
 export const fetchMedicalInfo = createAsyncThunk<
   createMedicalInfoParams,
diff --git a/Lifeline-Frontend/src/features/auth/screens/EmergencyContacts.tsx b/Lifeline-Frontend/src/features/auth/screens/EmergencyContacts.tsx
index 24d5628..9e44850 100644
--- a/Lifeline-Frontend/src/features/auth/screens/EmergencyContacts.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/EmergencyContacts.tsx
@@ -32,14 +32,14 @@ const EmergencyContactsScreen = forwardRef<EmergencyContactsScreenHandle, Props>
   ({ onSubmit }, ref) => {
     // Keep screen awake while filling emergency contacts.
     useKeepAwake();
-    let {
+    const {
       medicalInfo,
       contacts: contactsFromStore,
       isLoading: isLoadingMedical,
     } = useSelector((state: RootState) => state.medical);
     const hasExistingData = contactsFromStore && contactsFromStore.length > 0;
 
-    let dispatch = useDispatch();
+    const dispatch = useDispatch();
 
     const [contacts, setContacts] = useState<contactParams[]>([]);
 
@@ -47,7 +47,7 @@ const EmergencyContactsScreen = forwardRef<EmergencyContactsScreenHandle, Props>
       if (medicalInfo?._id) {
         dispatch(getContacts(String(medicalInfo._id)) as any);
       }
-    }, [medicalInfo?._id]);
+    }, [dispatch, medicalInfo?._id]);
 
     useEffect(() => {
       if (contactsFromStore && contactsFromStore.length > 0) {
diff --git a/Lifeline-Frontend/src/features/auth/screens/MedicalInfoScreen.tsx b/Lifeline-Frontend/src/features/auth/screens/MedicalInfoScreen.tsx
index 86b786b..5702fd6 100644
--- a/Lifeline-Frontend/src/features/auth/screens/MedicalInfoScreen.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/MedicalInfoScreen.tsx
@@ -1,12 +1,5 @@
 import { RootState } from "@/src/core/store";
-import React, {
-  forwardRef,
-  use,
-  useCallback,
-  useEffect,
-  useImperativeHandle,
-  useState,
-} from "react";
+import React, { forwardRef, useCallback, useEffect, useImperativeHandle, useState } from "react";
 import {
   ScrollView,
   StyleSheet,
@@ -26,7 +19,7 @@ import {
 import Ionicons from "react-native-vector-icons/Ionicons";
 import { useDispatch, useSelector } from "react-redux";
 import { resolveAuthToken } from "../authSession.utils";
-import { createMedicalInfo, createMedicalInfoParams, fetchMedicalInfo } from "../medicalSlice";
+import { fetchMedicalInfo } from "../medicalSlice";
 
 const BLOOD_TYPES = ["A+", "A-", "B+", "B-", "AB+", "AB-", "O+", "O-", "Unknown"];
 
@@ -288,13 +281,12 @@ export interface MedicalInfoScreenRef {
 const MedicalInfoScreen = forwardRef<MedicalInfoScreenRef, propType>(({ onSubmit }, ref) => {
   const [Error, setError] = useState("");
 
-  let user = useSelector((state: RootState) => state.auth);
-  let medical = useSelector((state: RootState) => state.medical.medicalInfo);
-  let medicalError = useSelector((state: RootState) => state.medical.error);
-  let isLoadingMedical = useSelector((state: RootState) => state.medical.isLoading);
+  const user = useSelector((state: RootState) => state.auth);
+  const medical = useSelector((state: RootState) => state.medical.medicalInfo);
+  const medicalError = useSelector((state: RootState) => state.medical.error);
   const hasExistingData = !!medical;
 
-  let dispatch = useDispatch();
+  const dispatch = useDispatch();
 
   // Fetch and set medical info if already exists in the store, otherwise initialize with empty values. Cleanup on unmount.
 
@@ -438,7 +430,7 @@ const MedicalInfoScreen = forwardRef<MedicalInfoScreenRef, propType>(({ onSubmit
     setMedications((prev) => prev.filter((_, i) => i !== index));
   }, []);
 
-  let medicalInfo = useSelector((state: RootState) => state.medical.medicalInfo);
+  const medicalInfo = medical;
 
   useEffect(() => {
     if (medicalInfo) {
@@ -502,9 +494,9 @@ const MedicalInfoScreen = forwardRef<MedicalInfoScreenRef, propType>(({ onSubmit
     };
   }, [medicalInfo]);
 
-  let handleSubmit = () => {
+  const handleSubmit = () => {
     if (onSubmit) {
-      let res = onSubmit({
+      onSubmit({
         bloodType,
         dateOfBirth,
         height,
diff --git a/Lifeline-Frontend/src/features/auth/screens/SecureLocationScreen.tsx b/Lifeline-Frontend/src/features/auth/screens/SecureLocationScreen.tsx
index 280b4ce..2fc494c 100644
--- a/Lifeline-Frontend/src/features/auth/screens/SecureLocationScreen.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/SecureLocationScreen.tsx
@@ -1,4 +1,4 @@
-import React, { useState, forwardRef, useImperativeHandle, useEffect } from "react";
+import React, { useState, forwardRef, useImperativeHandle, useEffect, useRef } from "react";
 import {
   View,
   Text,
@@ -9,7 +9,6 @@ import {
   ScrollView,
   KeyboardAvoidingView,
   Platform,
-  ActivityIndicator,
 } from "react-native";
 import * as Location from "expo-location";
 import {
@@ -39,12 +38,152 @@ type Props = {
   onSubmit?: (data: any) => void;
 };
 
+type NominatimReverseResponse = {
+  display_name?: string;
+  address?: {
+    house_number?: string;
+    road?: string;
+    pedestrian?: string;
+    footway?: string;
+    cycleway?: string;
+    path?: string;
+    suburb?: string;
+    neighbourhood?: string;
+    village?: string;
+    town?: string;
+    city?: string;
+    state?: string;
+    postcode?: string;
+  };
+};
+
+type PhotonReverseResponse = {
+  features?: Array<{
+    properties?: {
+      housenumber?: string;
+      street?: string;
+      name?: string;
+      city?: string;
+      district?: string;
+      state?: string;
+      postcode?: string;
+    };
+  }>;
+};
+
+type ReverseAddressResult = {
+  street: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  displayLine?: string;
+};
+
+const firstNonEmpty = (...values: Array<string | null | undefined>): string => {
+  for (const value of values) {
+    const normalized = (value || "").trim();
+    if (normalized) return normalized;
+  }
+  return "";
+};
+
+const displayNameToStreet = (displayName?: string): string => {
+  const firstChunk = (displayName || "").split(",")[0] || "";
+  return firstChunk.trim();
+};
+
+const buildStreetLine = (houseNumber?: string | null, road?: string | null): string => {
+  const house = (houseNumber || "").trim();
+  const roadName = (road || "").trim();
+  return `${house} ${roadName}`.trim();
+};
+
+const fetchOpenStreetMapAddress = async (
+  lat: number,
+  lng: number
+): Promise<ReverseAddressResult | null> => {
+  try {
+    const endpoint =
+      `https://nominatim.openstreetmap.org/reverse?format=jsonv2` +
+      `&lat=${encodeURIComponent(String(lat))}` +
+      `&lon=${encodeURIComponent(String(lng))}` +
+      `&addressdetails=1&zoom=18` +
+      `&email=${encodeURIComponent("support@lifeline.app")}`;
+
+    const response = await fetch(endpoint, {
+      headers: {
+        Accept: "application/json",
+        "Accept-Language": "en",
+        "User-Agent": "LifeLineApp/1.0",
+      },
+    });
+
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as NominatimReverseResponse;
+
+    const addr = data.address;
+    if (!addr) return null;
+
+    const roadLike =
+      addr.road || addr.pedestrian || addr.footway || addr.cycleway || addr.path || "";
+    const street =
+      buildStreetLine(addr.house_number, roadLike) ||
+      (addr.neighbourhood || "").trim() ||
+      (addr.suburb || "").trim();
+
+    return {
+      street,
+      city: (addr.city || addr.town || addr.village || "").trim(),
+      state: (addr.state || "").trim(),
+      zipCode: (addr.postcode || "").trim(),
+      displayLine: displayNameToStreet(data.display_name),
+    };
+  } catch {
+    return null;
+  }
+};
+
+const fetchPhotonAddress = async (
+  lat: number,
+  lng: number
+): Promise<ReverseAddressResult | null> => {
+  try {
+    const endpoint =
+      `https://photon.komoot.io/reverse?lat=${encodeURIComponent(String(lat))}` +
+      `&lon=${encodeURIComponent(String(lng))}`;
+
+    const response = await fetch(endpoint, {
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as PhotonReverseResponse;
+    const props = data.features?.[0]?.properties;
+    if (!props) return null;
+
+    const street =
+      buildStreetLine(props.housenumber, props.street) || firstNonEmpty(props.name, props.street);
+
+    return {
+      street,
+      city: firstNonEmpty(props.city, props.district),
+      state: firstNonEmpty(props.state),
+      zipCode: firstNonEmpty(props.postcode),
+      displayLine: firstNonEmpty(props.name, props.street),
+    };
+  } catch {
+    return null;
+  }
+};
+
 const SecureLocationScreen = forwardRef<SecureLocationScreenHandle, Props>(({ onSubmit }, ref) => {
   const dispatch = useDispatch();
   const userId = useSelector((state: RootState) => state.auth.authId || state.auth.userId);
-  const { locations, isLoading: isLocationLoading } = useSelector(
-    (state: RootState) => state.location
-  );
+  const { locations } = useSelector((state: RootState) => state.location);
 
   const hasExistingData = locations && locations.length > 0;
   const [loading, setLoading] = useState(false);
@@ -55,44 +194,90 @@ const SecureLocationScreen = forwardRef<SecureLocationScreenHandle, Props>(({ on
   const [manualZip, setManualZip] = useState("");
   const [manualLat, setManualLat] = useState("");
   const [manualLng, setManualLng] = useState("");
+  const reverseLookupRequestId = useRef(0);
 
   useEffect(() => {
     if (userId) {
       dispatch(fetchUserLocations(userId) as any);
     }
-  }, [userId]);
+  }, [dispatch, userId]);
 
   useEffect(() => {
     if (hasExistingData) {
       const existing = locations[0];
+      const existingLat = Number(existing.coordinates?.[1]);
+      const existingLng = Number(existing.coordinates?.[0]);
+
       setLocation({
-        latitude: existing.coordinates[1],
-        longitude: existing.coordinates[0],
+        latitude: existingLat,
+        longitude: existingLng,
       });
-      setManualLat(existing.coordinates[1].toString());
-      setManualLng(existing.coordinates[0].toString());
-      setManualAddress(existing.address);
-      setManualCity(existing.city);
-      setManualState(existing.state);
-      setManualZip(existing.zipCode);
+      setManualLat(Number.isFinite(existingLat) ? existingLat.toString() : "");
+      setManualLng(Number.isFinite(existingLng) ? existingLng.toString() : "");
+      setManualAddress(existing.address || "");
+      setManualCity(existing.city || "");
+      setManualState(existing.state || "");
+      setManualZip(existing.zipCode || "");
+
+      const needsAddressEnrichment =
+        !(existing.address || "").trim() ||
+        !(existing.city || "").trim() ||
+        !(existing.state || "").trim() ||
+        !(existing.zipCode || "").trim();
+
+      if (needsAddressEnrichment && Number.isFinite(existingLat) && Number.isFinite(existingLng)) {
+        void reverseGeocode(existingLat, existingLng);
+      }
     }
   }, [hasExistingData, locations]);
 
   const reverseGeocode = async (lat: number, lng: number) => {
-    try {
-      const [address] = await Location.reverseGeocodeAsync({
-        latitude: lat,
-        longitude: lng,
-      });
+    const requestId = ++reverseLookupRequestId.current;
 
-      if (address) {
-        const streetPart = address.street || address.name || "";
-        const housePart = address.streetNumber ? address.streetNumber + " " : "";
-        setManualAddress(`${housePart}${streetPart}`);
-        setManualCity(address.city || address.district || address.subregion || "");
-        setManualState(address.region || "");
-        setManualZip(address.postalCode || "");
-      }
+    try {
+      // Use multiple free providers and pick the richest street line.
+      const [expoAddressList, photonAddress, osmAddress] = await Promise.all([
+        Location.reverseGeocodeAsync({
+          latitude: lat,
+          longitude: lng,
+        }).catch(() => []),
+        fetchPhotonAddress(lat, lng),
+        fetchOpenStreetMapAddress(lat, lng),
+      ]);
+
+      if (requestId !== reverseLookupRequestId.current) return;
+
+      const address = expoAddressList?.[0];
+
+      const expoStreet = buildStreetLine(address?.streetNumber, address?.street || address?.name);
+      const bestStreet = firstNonEmpty(
+        photonAddress?.street,
+        osmAddress?.street,
+        expoStreet,
+        photonAddress?.displayLine,
+        osmAddress?.displayLine
+      );
+
+      const bestCity = firstNonEmpty(
+        address?.city,
+        address?.district,
+        address?.subregion,
+        photonAddress?.city,
+        osmAddress?.city
+      );
+
+      const bestState = firstNonEmpty(address?.region, photonAddress?.state, osmAddress?.state);
+      const bestZip = firstNonEmpty(
+        address?.postalCode,
+        photonAddress?.zipCode,
+        osmAddress?.zipCode
+      );
+      const fallbackAddressLine = [bestCity, bestState, bestZip].filter(Boolean).join(", ");
+
+      setManualAddress((prev) => firstNonEmpty(bestStreet, prev, fallbackAddressLine));
+      setManualCity((prev) => firstNonEmpty(bestCity, prev));
+      setManualState((prev) => firstNonEmpty(bestState, prev));
+      setManualZip((prev) => firstNonEmpty(bestZip, prev));
     } catch (error) {
       console.error("Reverse geocoding error:", error);
     }
@@ -155,10 +340,7 @@ const SecureLocationScreen = forwardRef<SecureLocationScreenHandle, Props>(({ on
       "Selected location";
 
     const locationData = {
-      coordinates: [
-        longitude,
-        latitude,
-      ],
+      coordinates: [longitude, latitude],
       latitude,
       longitude,
       address: normalizedAddress,
diff --git a/Lifeline-Frontend/src/features/auth/screens/UniversalMap.tsx b/Lifeline-Frontend/src/features/auth/screens/UniversalMap.tsx
index 8f8ce06..d2d0fa7 100644
--- a/Lifeline-Frontend/src/features/auth/screens/UniversalMap.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/UniversalMap.tsx
@@ -1,5 +1,5 @@
 import React from "react";
-import { View, Text, Platform } from "react-native";
+import { View, Text } from "react-native";
 import { WebView } from "react-native-webview";
 import Ionicons from "react-native-vector-icons/Ionicons";
 
diff --git a/Lifeline-Frontend/src/features/auth/screens/UserInfo.tsx b/Lifeline-Frontend/src/features/auth/screens/UserInfo.tsx
index 748f65b..2d27c43 100644
--- a/Lifeline-Frontend/src/features/auth/screens/UserInfo.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/UserInfo.tsx
@@ -42,6 +42,8 @@ const UserInfo = forwardRef<UserInfoRef, UserInfoProps>(({ onSubmit }, ref) => {
 
   const [role, setRole] = useState<"user" | "helper">("user");
   const [image, setImage] = useState<string | null>(null);
+  const [imageMimeType, setImageMimeType] = useState<string | null>(null);
+  const [imageFileName, setImageFileName] = useState<string | null>(null);
   const [showPassword, setShowPassword] = useState(false);
   const [showConfirmPassword, setShowConfirmPassword] = useState(false);
   const [formData, setFormData] = useState({
@@ -83,8 +85,11 @@ const UserInfo = forwardRef<UserInfoRef, UserInfoProps>(({ onSubmit }, ref) => {
 
   const handleImagePick = async () => {
     const result = await filePicker();
-    if (!result.canceled) {
-      setImage(result.assets[0].uri);
+    if (!result.canceled && result.assets?.[0]) {
+      const asset = result.assets[0];
+      setImage(asset.uri);
+      setImageMimeType(asset.mimeType || null);
+      setImageFileName(asset.fileName || asset.uri.split("/").pop() || "profile.jpg");
     }
   };
 
@@ -159,14 +164,25 @@ const UserInfo = forwardRef<UserInfoRef, UserInfoProps>(({ onSubmit }, ref) => {
 
       // Add profile image if selected
       if (image && !image.startsWith("http")) {
-        const filename = image.split("/").pop() || "profile.jpg";
-        const match = /\.(\w+)$/.exec(filename);
-        const type = match ? `image/${match[1]}` : "image/jpeg";
+        const filename = imageFileName || image.split("/").pop() || "profile.jpg";
+        const extension = (filename.split(".").pop() || "").toLowerCase();
+        const normalizedMimeType =
+          imageMimeType ||
+          ({
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            png: "image/png",
+            webp: "image/webp",
+            gif: "image/gif",
+            heic: "image/heic",
+            heif: "image/heif",
+          }[extension] ??
+            "image/jpeg");
 
         submitData.append("profileImage", {
           uri: image,
           name: filename,
-          type,
+          type: normalizedMimeType,
         } as any);
       }
 
diff --git a/Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx b/Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx
index ec1350c..1b80258 100644
--- a/Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx
@@ -215,7 +215,6 @@ const skillCategoryBlueprint: SkillCategory[] = [
   },
 ];
 
-
 const skillLookup = new Set(skillsList);
 const usedSkills = new Set<string>();
 
@@ -248,12 +247,7 @@ if (uncategorizedSkills.length > 0) {
 const helperBasicSkills =
   skillCategories.find((category) => category.category === "helper-basics")?.skills ?? [];
 
-type BackendSkillCategory =
-  | "medical"
-  | "technical"
-  | "logistical"
-  | "emotional"
-  | "language";
+type BackendSkillCategory = "medical" | "technical" | "logistical" | "emotional" | "language";
 
 const backendCategoryByUiCategory: Record<string, BackendSkillCategory> = {
   "helper-basics": "logistical",
@@ -279,16 +273,12 @@ const resolveSkillCategory = (skill: string): BackendSkillCategory => {
   return skillToBackendCategory.get(skill) || "technical";
 };
 
-
-
-
 export interface VerifySkillsScreenRef {
   handleSubmit: () => Promise<boolean>;
 }
 
 const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
   const [selectedSkills, setSelectedSkills] = useState<string[]>([]);
-  const [loading, setLoading] = useState(false);
   const { userId, authId } = useSelector((state: RootState) => state.auth);
   const helperIdentifier = authId || userId;
 
@@ -317,7 +307,6 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
         Alert.alert("No Skills Selected", "Please select at least one skill.");
         return false;
       }
-      setLoading(true);
       try {
         const skillsPayload = selectedSkills.map((name) => ({
           name,
@@ -333,8 +322,6 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
           err?.response?.data?.message || err?.message || "Failed to update skills"
         );
         return false;
-      } finally {
-        setLoading(false);
       }
     },
   }));
@@ -342,7 +329,7 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
   return (
     <View style={styles.container}>
       <View style={styles.header}>
-        <Ionicons name="arrow-back" size={hp("2.5%")}/>
+        <Ionicons name="arrow-back" size={hp("2.5%")} />
         <Text style={styles.step}>STEP 2 OF 4</Text>
       </View>
 
@@ -358,7 +345,7 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
         </View>
         <View style={styles.summaryActions}>
           <TouchableOpacity style={styles.primaryAction} onPress={selectHelperBasics}>
-            <Ionicons name="flash-outline" size={hp("1.8%")}/>
+            <Ionicons name="flash-outline" size={hp("1.8%")} />
             <Text style={styles.primaryActionText}>Select Basics</Text>
           </TouchableOpacity>
           <TouchableOpacity style={styles.secondaryAction} onPress={clearSelection}>
@@ -384,7 +371,7 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
                   style={[styles.chip, active && styles.chipActive]}
                   onPress={() => toggleSkill(skill)}
                 >
-                  {active && <Ionicons name="checkmark" size={hp("1.6%")}/>} 
+                  {active && <Ionicons name="checkmark" size={hp("1.6%")} />}
                   <Text style={[styles.chipText, active && styles.chipTextActive]}>{skill}</Text>
                 </TouchableOpacity>
               );
@@ -395,7 +382,7 @@ const VerifySkillsScreen = forwardRef<VerifySkillsScreenRef>((props, ref) => {
     </View>
   );
 });
-       
+
 VerifySkillsScreen.displayName = "VerifySkillsScreen";
 
 export default VerifySkillsScreen;
diff --git a/Lifeline-Frontend/src/features/auth/screens/WelcomeScreen.tsx b/Lifeline-Frontend/src/features/auth/screens/WelcomeScreen.tsx
index c49601c..4f9ffe9 100644
--- a/Lifeline-Frontend/src/features/auth/screens/WelcomeScreen.tsx
+++ b/Lifeline-Frontend/src/features/auth/screens/WelcomeScreen.tsx
@@ -3,7 +3,7 @@ import { View, Text, StyleSheet } from "react-native";
 import { useTheme } from "@/src/theme/useTheme";
 
 export const WelcomeScreen = () => {
-  const { colors, spacing, typography } = useTheme();
+  const { colors, spacing } = useTheme();
 
   return (
     <View style={[styles.container, { backgroundColor: colors.background.default }]}>
diff --git a/Lifeline-Frontend/src/features/emergency/emergencySlice.ts b/Lifeline-Frontend/src/features/emergency/emergencySlice.ts
index 91921e5..78a24fb 100644
--- a/Lifeline-Frontend/src/features/emergency/emergencySlice.ts
+++ b/Lifeline-Frontend/src/features/emergency/emergencySlice.ts
@@ -5,7 +5,7 @@
  */
 
 import { createSlice, createAsyncThunk, PayloadAction } from "@reduxjs/toolkit";
-import api, { API_ENDPOINTS } from "../../config/api";
+import { api, API_ENDPOINTS } from "../../config/api";
 import { triageApiService } from "./services/triageApi.service";
 
 // ============================================
@@ -181,6 +181,7 @@ export const startTriageSession = createAsyncThunk(
       location: Location;
       language?: string;
       emergencyType?: EmergencyType;
+      emergencyId?: string;
     },
     { rejectWithValue }
   ) => {
@@ -189,6 +190,7 @@ export const startTriageSession = createAsyncThunk(
         location: data.location,
         language: data.language,
         emergencyType: data.emergencyType,
+        emergencyId: data.emergencyId,
       });
     } catch (error: unknown) {
       const axiosError = error as { response?: { data?: { message?: string } } };
@@ -355,6 +357,59 @@ export const resolveEmergency = createAsyncThunk(
   }
 );
 
+/**
+ * Approve emergency payment (send OTP)
+ */
+export const approveEmergencyPayment = createAsyncThunk(
+  "emergency/approvePayment",
+  async (emergencyId: string, { rejectWithValue }) => {
+    try {
+      const response = await api.post(API_ENDPOINTS.EMERGENCY.PAYMENT.APPROVE(emergencyId));
+      return response.data.data;
+    } catch (error: unknown) {
+      const axiosError = error as { response?: { data?: { message?: string } } };
+      return rejectWithValue(axiosError.response?.data?.message || "Failed to approve payment");
+    }
+  }
+);
+
+/**
+ * Verify emergency payment OTP
+ */
+export const verifyEmergencyOtp = createAsyncThunk(
+  "emergency/verifyOtp",
+  async (data: { emergencyId: string; otp: string }, { rejectWithValue }) => {
+    try {
+      const response = await api.post(
+        API_ENDPOINTS.EMERGENCY.PAYMENT.VERIFY_OTP(data.emergencyId),
+        {
+          otp: data.otp,
+        }
+      );
+      return response.data.data;
+    } catch (error: unknown) {
+      const axiosError = error as { response?: { data?: { message?: string } } };
+      return rejectWithValue(axiosError.response?.data?.message || "Failed to verify OTP");
+    }
+  }
+);
+
+/**
+ * Fetch SOS profile for helper
+ */
+export const getSOSProfile = createAsyncThunk(
+  "emergency/getProfile",
+  async (emergencyId: string, { rejectWithValue }) => {
+    try {
+      const response = await api.get(API_ENDPOINTS.EMERGENCY.PROFILE(emergencyId));
+      return response.data.data;
+    } catch (error: unknown) {
+      const axiosError = error as { response?: { data?: { message?: string } } };
+      return rejectWithValue(axiosError.response?.data?.message || "Failed to get SOS profile");
+    }
+  }
+);
+
 /**
  * Get user's emergency history
  */
@@ -402,9 +457,24 @@ export const getNearbyEmergencies = createAsyncThunk(
  */
 export const acceptHelperRequest = createAsyncThunk(
   "emergency/acceptHelper",
-  async (emergencyId: string, { rejectWithValue }) => {
+  async (
+    params:
+      | string
+      | {
+          emergencyId: string;
+          serviceType?: string;
+          amount?: number;
+          method?: "cash" | "upi" | "card";
+        },
+    { rejectWithValue }
+  ) => {
     try {
-      const response = await api.put(API_ENDPOINTS.EMERGENCY.ACCEPT(emergencyId));
+      const payload = typeof params === "string" ? { emergencyId: params } : { ...params };
+      const response = await api.put(API_ENDPOINTS.EMERGENCY.ACCEPT(payload.emergencyId), {
+        serviceType: payload.serviceType,
+        amount: payload.amount,
+        method: payload.method,
+      });
       return response.data.data;
     } catch (error: unknown) {
       const axiosError = error as { response?: { data?: { message?: string } } };
diff --git a/Lifeline-Frontend/src/features/emergency/hooks/useEmergency.ts b/Lifeline-Frontend/src/features/emergency/hooks/useEmergency.ts
index f02011c..a2ca97a 100644
--- a/Lifeline-Frontend/src/features/emergency/hooks/useEmergency.ts
+++ b/Lifeline-Frontend/src/features/emergency/hooks/useEmergency.ts
@@ -388,12 +388,8 @@ export const useEmergency = (): UseEmergencyReturn => {
   useEffect(() => {
     if (!isConnected) return;
 
-    const activePhases: SOSPhase[] = [
-      "waiting_for_helper",
-      "helper_en_route",
-      "helper_arrived",
-    ];
-    if (!activePhases.includes(phase)) return;
+    const activePhases: SOSPhase[] = ["waiting_for_helper", "helper_en_route", "helper_arrived"];
+    if (activePhases.indexOf(phase) === -1) return;
 
     const requestNearbyHelpers = () => {
       const location = userLocationRef.current;
@@ -427,6 +423,7 @@ export const useEmergency = (): UseEmergencyReturn => {
         priority?: string;
         medicalInfo?: Record<string, unknown>;
       };
+      emergencyData?: Emergency;
       aiMessage?: string;
     }) => {
       if (response.aiMessage) {
@@ -434,29 +431,18 @@ export const useEmergency = (): UseEmergencyReturn => {
         await aiConversation.speak(response.aiMessage);
       }
 
-      if (response.decision === "create_emergency" && response.emergency) {
-        // Trigger SOS with AI-determined emergency data
+      if (response.decision === "create_emergency") {
         setPhase("dispatching");
         setCurrentMessage(messages.confirmEmergency);
         await aiConversation.speak(messages.confirmEmergency);
 
-        const location = emergencyState.userLocation;
-        if (location) {
-          await dispatch(
-            triggerSOS({
-              title: response.emergency.title || "Emergency",
-              message: response.emergency.description || "",
-              type: (response.emergency.type as EmergencyType) || "other",
-              priority:
-                (response.emergency.priority as "critical" | "high" | "medium" | "low") || "high",
-              location,
-            })
-          ).unwrap();
-
-          setPhase("waiting_for_helper");
-          setCurrentMessage(messages.helpOnWay);
-          await aiConversation.speak(messages.helpOnWay);
+        if (response.emergencyData) {
+          dispatch(setActiveEmergency(response.emergencyData));
         }
+
+        setPhase("waiting_for_helper");
+        setCurrentMessage(messages.helpOnWay);
+        await aiConversation.speak(messages.helpOnWay);
       } else if (response.decision === "no_emergency" && response.guidance) {
         // Minor issue - provide guidance
         setCurrentMessage(messages.minorIssue + " " + response.guidance);
@@ -467,7 +453,7 @@ export const useEmergency = (): UseEmergencyReturn => {
         setPhase("listening");
       }
     },
-    [dispatch, emergencyState.userLocation, messages, aiConversation]
+    [dispatch, messages, aiConversation]
   );
 
   // Initiate SOS - uses socket for real-time AI communication
@@ -485,23 +471,43 @@ export const useEmergency = (): UseEmergencyReturn => {
           dispatch(setSelectedEmergencyType(type));
         }
 
+        const normalizedType = type === "safety" ? "other" : type || "medical";
+        const safeLocation: Location = {
+          ...location,
+          address: location.address || "Unknown location",
+        };
+        const sosResult = await dispatch(
+          triggerSOS({
+            title: normalizedType ? `${normalizedType} SOS` : "SOS Emergency",
+            message: "User initiated SOS",
+            type: normalizedType as EmergencyType,
+            priority: "critical",
+            location: safeLocation,
+          })
+        ).unwrap();
+
+        const emergencyId =
+          (sosResult?.emergency?.id || sosResult?.emergency?._id || sosResult?.emergencyId) ?? null;
+
         // Use socket for real-time triage (preferred method)
         if (isConnected) {
           emit(SOCKET_EVENTS.TRIAGE.START_SESSION, {
             location: {
-              latitude: location.latitude,
-              longitude: location.longitude,
+              latitude: safeLocation.latitude,
+              longitude: safeLocation.longitude,
             },
             language,
             emergencyType: type,
+            emergencyId,
           });
         } else {
           // Fallback to HTTP API
           const result = await dispatch(
             startTriageSession({
-              location,
+              location: safeLocation,
               language,
               emergencyType: type,
+              emergencyId,
             })
           ).unwrap();
 
diff --git a/Lifeline-Frontend/src/features/emergency/services/triageApi.service.ts b/Lifeline-Frontend/src/features/emergency/services/triageApi.service.ts
index b3325a7..af25e79 100644
--- a/Lifeline-Frontend/src/features/emergency/services/triageApi.service.ts
+++ b/Lifeline-Frontend/src/features/emergency/services/triageApi.service.ts
@@ -4,8 +4,8 @@
  * @version 1.0.0
  */
 
-import api, { API_ENDPOINTS } from "../../../config/api";
-import type { EmergencyType, Location } from "../emergencySlice";
+import { api, API_ENDPOINTS } from "../../../config/api";
+import type { Emergency, EmergencyType, Location } from "../emergencySlice";
 
 // ============================================
 // BACKEND RESPONSE TYPES
@@ -98,7 +98,7 @@ export interface TriageMessageResult {
   fastTracked?: boolean;
   emergencyCreated?: boolean;
   emergencyId?: string;
-  emergencyData?: Record<string, unknown>;
+  emergencyData?: Emergency;
   session: Record<string, unknown>;
 }
 
@@ -130,6 +130,7 @@ export const triageApiService = {
     location: Location;
     language?: string;
     emergencyType?: EmergencyType;
+    emergencyId?: string;
   }): Promise<TriageStartResult> {
     const response = await api.post<BackendStartSessionResponse>(API_ENDPOINTS.TRIAGE.START, {
       location: {
@@ -138,6 +139,7 @@ export const triageApiService = {
       },
       language: params.language || "en",
       emergencyType: params.emergencyType,
+      emergencyId: params.emergencyId,
     });
 
     const data = response.data;
@@ -181,7 +183,7 @@ export const triageApiService = {
       fastTracked: data.fastTracked,
       emergencyCreated: data.emergencyCreated,
       emergencyId: data.emergencyId,
-      emergencyData: data.emergencyData,
+      emergencyData: data.emergencyData as Emergency | undefined,
       session: data.session,
     };
   },
diff --git a/Lifeline-Frontend/src/shared/hooks/useBackgroundLocation.ts b/Lifeline-Frontend/src/shared/hooks/useBackgroundLocation.ts
index 1c13102..6ca21f3 100644
--- a/Lifeline-Frontend/src/shared/hooks/useBackgroundLocation.ts
+++ b/Lifeline-Frontend/src/shared/hooks/useBackgroundLocation.ts
@@ -4,6 +4,8 @@ import * as TaskManager from "expo-task-manager";
 import { LOCATION_TASK_NAME } from "../tasks/location.task";
 import { Alert } from "react-native";
 
+const HELPER_LOCATION_UPDATE_INTERVAL_MS = 5000;
+
 export const useBackgroundLocation = () => {
   const [isTracking, setIsTracking] = useState(false);
 
@@ -57,9 +59,10 @@ export const useBackgroundLocation = () => {
       }
 
       await Location.startLocationUpdatesAsync(LOCATION_TASK_NAME, {
-        accuracy: Location.Accuracy.Balanced,
-        timeInterval: 5000, // 5 seconds
-        distanceInterval: 5, // 5 meters
+        accuracy: Location.Accuracy.Highest,
+        timeInterval: HELPER_LOCATION_UPDATE_INTERVAL_MS,
+        deferredUpdatesInterval: HELPER_LOCATION_UPDATE_INTERVAL_MS,
+        distanceInterval: 0, // Always allow 5-second interval updates
         foregroundService: {
           notificationTitle: "LifeLine Background Tracking",
           notificationBody: "Reporting location to help during emergencies.",
diff --git a/Lifeline-Frontend/src/shared/hooks/useSocket.ts b/Lifeline-Frontend/src/shared/hooks/useSocket.ts
index e71bca9..3440ec3 100644
--- a/Lifeline-Frontend/src/shared/hooks/useSocket.ts
+++ b/Lifeline-Frontend/src/shared/hooks/useSocket.ts
@@ -6,8 +6,7 @@
 
 import { useEffect, useCallback, useState, useRef } from "react";
 import { useSelector, useDispatch } from "react-redux";
-import socketService, { ConnectionState, SocketServiceState } from "../services/socket.service";
-import { SOCKET_EVENTS } from "../../config/socket";
+import { socketService, ConnectionState, SocketServiceState } from "../services/socket.service";
 import { RootState, AppDispatch } from "../../core/store";
 import {
   setSocketConnected,
@@ -42,7 +41,6 @@ export const useSocket = (options: UseSocketOptions = {}): UseSocketReturn => {
 
   const dispatch = useDispatch<AppDispatch>();
   const authState = useSelector((state: RootState) => state.auth);
-  const socketState = useSelector((state: RootState) => state.socket);
 
   const [localState, setLocalState] = useState<SocketServiceState>(socketService.getState());
 
diff --git a/Lifeline-Frontend/src/shared/services/socket.service.ts b/Lifeline-Frontend/src/shared/services/socket.service.ts
index 50fa969..935b7f9 100644
--- a/Lifeline-Frontend/src/shared/services/socket.service.ts
+++ b/Lifeline-Frontend/src/shared/services/socket.service.ts
@@ -227,10 +227,7 @@ class SocketService {
     this.updateState({ userId });
 
     if (this.socket?.connected) {
-      this.socket.emit(
-        SOCKET_EVENTS.USER.REGISTER,
-        role ? { userId, role } : userId
-      );
+      this.socket.emit(SOCKET_EVENTS.USER.REGISTER, role ? { userId, role } : userId);
       console.log("📤 Registering user:", userId);
     } else {
       console.log("Socket not connected, will register when connected");
@@ -393,9 +390,11 @@ class SocketService {
     speed?: number;
     heading?: number;
     userId?: string;
+    role?: "user" | "helper";
     timestamp?: string | number;
   }): void {
-    const { latitude, longitude, accuracy, altitude, speed, heading, timestamp } = location;
+    const { latitude, longitude, accuracy, altitude, speed, heading, timestamp, userId, role } =
+      location;
     this.emit(SOCKET_EVENTS.LOCATION.UPDATE, {
       latitude,
       longitude,
@@ -403,6 +402,8 @@ class SocketService {
       altitude,
       speed,
       heading,
+      userId,
+      role,
       timestamp: timestamp || new Date().toISOString(),
     });
   }
@@ -492,11 +493,17 @@ class SocketService {
   /**
    * Start Triage Session
    */
-  startTriageSession(location?: any, language?: string, emergencyType?: string): void {
+  startTriageSession(
+    location?: any,
+    language?: string,
+    emergencyType?: string,
+    emergencyId?: string
+  ): void {
     this.emit(SOCKET_EVENTS.TRIAGE.START_SESSION, {
       location,
       language,
       emergencyType,
+      emergencyId,
     });
   }
 
diff --git a/Lifeline-Frontend/src/shared/services/speech.service.ts b/Lifeline-Frontend/src/shared/services/speech.service.ts
index 41ea0cb..9949b3f 100644
--- a/Lifeline-Frontend/src/shared/services/speech.service.ts
+++ b/Lifeline-Frontend/src/shared/services/speech.service.ts
@@ -15,6 +15,7 @@ let ExpoSpeechRecognitionModule: any = null;
 let useSpeechRecognitionEvent: any = (_event: string, _cb: (...args: any[]) => void) => {};
 
 try {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
   const mod = require("expo-speech-recognition");
   ExpoSpeechRecognitionModule = mod.ExpoSpeechRecognitionModule;
   useSpeechRecognitionEvent = mod.useSpeechRecognitionEvent;
@@ -332,7 +333,7 @@ class SpeechToTextService {
     try {
       const permissions = await ExpoSpeechRecognitionModule.getPermissionsAsync();
       return permissions.granted;
-    } catch (error) {
+    } catch {
       return false;
     }
   }
diff --git a/Lifeline-Frontend/src/shared/store/middleware/socketMiddleware.ts b/Lifeline-Frontend/src/shared/store/middleware/socketMiddleware.ts
index f9fed0f..355164c 100644
--- a/Lifeline-Frontend/src/shared/store/middleware/socketMiddleware.ts
+++ b/Lifeline-Frontend/src/shared/store/middleware/socketMiddleware.ts
@@ -1,5 +1,5 @@
 import { Middleware } from "@reduxjs/toolkit";
-import socketService from "../../services/socket.service";
+import { socketService } from "../../services/socket.service";
 import { SOCKET_EVENTS } from "../../../config/socket";
 import {
   addTriageMessage,
diff --git a/Lifeline-Frontend/src/shared/tasks/location.task.ts b/Lifeline-Frontend/src/shared/tasks/location.task.ts
index cd127d9..e8e4596 100644
--- a/Lifeline-Frontend/src/shared/tasks/location.task.ts
+++ b/Lifeline-Frontend/src/shared/tasks/location.task.ts
@@ -1,9 +1,28 @@
 import * as TaskManager from "expo-task-manager";
-import * as Location from "expo-location";
-import socketService from "../services/socket.service";
+import { socketService } from "../services/socket.service";
 import AsyncStorage from "@react-native-async-storage/async-storage";
+import { LocationEmitSample, stabilizeLocationUpdate } from "@/src/shared/utils/locationStabilizer";
 
 export const LOCATION_TASK_NAME = "background-location-task";
+const lastBackgroundLocationByUser = new Map<string, LocationEmitSample>();
+const lastBackgroundEmitAtByUser = new Map<string, number>();
+const backgroundTrackingStartedAtByUser = new Map<string, number>();
+const MIN_BACKGROUND_EMIT_INTERVAL_MS = 4500;
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const ensureSocketReady = async (userId: string, role: "user" | "helper") => {
+  if (!socketService.isConnected()) {
+    socketService.connect();
+    await sleep(800);
+  }
+
+  if (!socketService.isConnected()) return false;
+
+  socketService.registerUser(userId, role);
+  await sleep(100);
+  return socketService.isConnected();
+};
 
 // Define the background task
 TaskManager.defineTask(LOCATION_TASK_NAME, async ({ data, error }: any) => {
@@ -16,32 +35,83 @@ TaskManager.defineTask(LOCATION_TASK_NAME, async ({ data, error }: any) => {
     const { locations } = data;
     if (locations && locations.length > 0) {
       const location = locations[0];
-      const { latitude, longitude, accuracy, altitude, speed, heading, timestamp } =
-        location.coords;
+      const { latitude, longitude, accuracy, altitude, speed, heading } = location.coords;
+      const sampleTimestamp = new Date().toISOString();
 
       try {
         const userId = await AsyncStorage.getItem("user_id");
         const isAvailable = await AsyncStorage.getItem("is_available");
+        const storedRole = await AsyncStorage.getItem("user_role");
+        const role: "user" | "helper" = storedRole === "helper" ? "helper" : "user";
 
         if (!userId) {
           console.warn("[Background] No user_id found in storage, skipping update.");
           return;
         }
 
-        if (isAvailable !== "true") {
+        // Helper location should only be broadcast when helper is available.
+        if (role === "helper" && isAvailable !== "true") {
           console.log("[Background] Helper not available, skipping update.");
           return;
         }
 
-        console.log(`[Background] 📍 Reporting location for ${userId}: ${latitude}, ${longitude}`);
+        const isSocketReady = await ensureSocketReady(userId, role);
+        if (!isSocketReady) {
+          console.warn("[Background] Socket not ready, skipping location emit.");
+          return;
+        }
+
+        const trackerKey = `${role}:${userId}`;
+        const now = Date.now();
+        if (!backgroundTrackingStartedAtByUser.has(trackerKey)) {
+          backgroundTrackingStartedAtByUser.set(trackerKey, now);
+        }
+
+        const lastEmitAt = lastBackgroundEmitAtByUser.get(trackerKey) || 0;
+        if (now - lastEmitAt < MIN_BACKGROUND_EMIT_INTERVAL_MS) {
+          return;
+        }
+
+        const decision = stabilizeLocationUpdate({
+          previous: lastBackgroundLocationByUser.get(trackerKey) || null,
+          incoming: {
+            latitude,
+            longitude,
+            accuracy: accuracy || undefined,
+            altitude: altitude || undefined,
+            speed: speed || undefined,
+            heading: heading || undefined,
+            timestamp: sampleTimestamp,
+          },
+          minEmitIntervalMs: MIN_BACKGROUND_EMIT_INTERVAL_MS,
+          lastEmitAtMs: lastEmitAt || undefined,
+          trackingStartedAtMs: backgroundTrackingStartedAtByUser.get(trackerKey),
+          forceEmitAfterMs: 15000,
+          nowMs: now,
+        });
+
+        if (!decision.shouldEmit) {
+          return;
+        }
+
+        const sample = decision.sample;
+        lastBackgroundLocationByUser.set(trackerKey, sample);
+        lastBackgroundEmitAtByUser.set(trackerKey, now);
+
+        console.log(
+          `[Background] 📍 Reporting location for ${userId}: ${sample.latitude}, ${sample.longitude}`
+        );
         socketService.updateLocation({
-          latitude,
-          longitude,
-          accuracy: accuracy || undefined,
-          altitude: altitude || undefined,
-          speed: speed || undefined,
-          heading: heading || undefined,
-          userId: userId, // Ensure userId is sent
+          latitude: sample.latitude,
+          longitude: sample.longitude,
+          accuracy: sample.accuracy,
+          altitude: sample.altitude,
+          speed: sample.speed,
+          heading: sample.heading,
+          userId,
+          role,
+          timestamp:
+            typeof sample.timestamp === "string" ? sample.timestamp : new Date().toISOString(),
         });
       } catch (err: any) {
         console.error("Background Location Update Failed:", err.message);
diff --git a/Lifeline-Frontend/src/shared/utils/error.utils.ts b/Lifeline-Frontend/src/shared/utils/error.utils.ts
index b3b2e8b..ca18cb5 100644
--- a/Lifeline-Frontend/src/shared/utils/error.utils.ts
+++ b/Lifeline-Frontend/src/shared/utils/error.utils.ts
@@ -3,7 +3,7 @@ import { AxiosError } from "axios";
 type ApiErrorPayload = {
   message?: string;
   error?: string;
-  errors?: Array<{ message?: string } | string>;
+  errors?: ({ message?: string } | string)[];
 };
 
 export const getErrorMessage = (error: unknown, fallback = "Something went wrong"): string => {
diff --git a/Lifeline-Frontend/src/shared/utils/locationStabilizer.ts b/Lifeline-Frontend/src/shared/utils/locationStabilizer.ts
new file mode 100644
index 0000000..7180f33
--- /dev/null
+++ b/Lifeline-Frontend/src/shared/utils/locationStabilizer.ts
@@ -0,0 +1,320 @@
+export type LocationEmitSample = {
+  latitude: number;
+  longitude: number;
+  accuracy?: number;
+  altitude?: number;
+  speed?: number;
+  heading?: number;
+  timestamp?: string | number | Date;
+};
+
+export type LocationStabilizeDecision = {
+  shouldEmit: boolean;
+  reason: string;
+  sample: LocationEmitSample;
+  distanceMeters: number;
+  thresholdMeters: number;
+};
+
+type StabilizerConfig = {
+  minEmitIntervalMs?: number;
+  lastEmitAtMs?: number;
+  trackingStartedAtMs?: number;
+  forceEmitAfterMs?: number;
+  nowMs?: number;
+  maxStaleNegativeSkewMs?: number;
+};
+
+const MAX_ACCEPTABLE_ACCURACY_METERS = 80;
+const MIN_JITTER_THRESHOLD_METERS = 3;
+const MAX_JITTER_THRESHOLD_METERS = 22;
+const STATIONARY_SPEED_THRESHOLD_MPS = 0.8;
+const MAX_SMOOTHING_DISTANCE_METERS = 35;
+const MIN_STATIONARY_MOVE_METERS = 10;
+const DEFAULT_FORCE_EMIT_AFTER_MS = 15000;
+const DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS = 15000;
+
+const isFiniteNumber = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value);
+
+const normalizeAccuracy = (accuracy?: number): number | undefined => {
+  if (!isFiniteNumber(accuracy) || accuracy < 0) return undefined;
+  return accuracy;
+};
+
+const toIsoTimestamp = (timestamp?: string | number | Date): string => {
+  if (timestamp instanceof Date && !Number.isNaN(timestamp.getTime())) {
+    return timestamp.toISOString();
+  }
+
+  if (typeof timestamp === "number" && Number.isFinite(timestamp)) {
+    const asDate = new Date(timestamp);
+    if (!Number.isNaN(asDate.getTime())) return asDate.toISOString();
+  }
+
+  if (typeof timestamp === "string") {
+    const asDate = new Date(timestamp);
+    if (!Number.isNaN(asDate.getTime())) return asDate.toISOString();
+  }
+
+  return new Date().toISOString();
+};
+
+const toRadians = (value: number) => (value * Math.PI) / 180;
+
+export const haversineDistanceMeters = (
+  startLat: number,
+  startLon: number,
+  endLat: number,
+  endLon: number
+): number => {
+  const earthRadiusMeters = 6371000;
+  const dLat = toRadians(endLat - startLat);
+  const dLon = toRadians(endLon - startLon);
+  const lat1 = toRadians(startLat);
+  const lat2 = toRadians(endLat);
+
+  const a =
+    Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+    Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+
+  return earthRadiusMeters * (2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)));
+};
+
+const computeJitterThresholdMeters = (
+  previousAccuracy?: number,
+  incomingAccuracy?: number
+): number => {
+  const prev = normalizeAccuracy(previousAccuracy) ?? 8;
+  const next = normalizeAccuracy(incomingAccuracy) ?? 8;
+  const threshold = (prev + next) * 0.55;
+
+  return Math.max(MIN_JITTER_THRESHOLD_METERS, Math.min(MAX_JITTER_THRESHOLD_METERS, threshold));
+};
+
+const weightedAverage = (
+  previousValue: number,
+  incomingValue: number,
+  previousAccuracy?: number,
+  incomingAccuracy?: number
+): number => {
+  const prevWeight = 1 / Math.max(normalizeAccuracy(previousAccuracy) ?? 8, 3);
+  const incomingWeight = 1 / Math.max(normalizeAccuracy(incomingAccuracy) ?? 8, 3);
+  return (
+    (previousValue * prevWeight + incomingValue * incomingWeight) / (prevWeight + incomingWeight)
+  );
+};
+
+const hasValidCoordinate = (latitude: number, longitude: number): boolean =>
+  latitude >= -90 && latitude <= 90 && longitude >= -180 && longitude <= 180;
+
+export const stabilizeLocationUpdate = ({
+  previous,
+  incoming,
+  minEmitIntervalMs = 4500,
+  lastEmitAtMs,
+  trackingStartedAtMs,
+  forceEmitAfterMs = DEFAULT_FORCE_EMIT_AFTER_MS,
+  nowMs = Date.now(),
+  maxStaleNegativeSkewMs = DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS,
+}: {
+  previous?: LocationEmitSample | null;
+  incoming: LocationEmitSample;
+} & StabilizerConfig): LocationStabilizeDecision => {
+  const hasLastEmit = isFiniteNumber(lastEmitAtMs) && lastEmitAtMs > 0;
+  const hasTrackingStart = isFiniteNumber(trackingStartedAtMs) && trackingStartedAtMs > 0;
+  const millisSinceLastEmit = hasLastEmit ? nowMs - (lastEmitAtMs as number) : 0;
+  const millisSinceTrackingStart = hasTrackingStart ? nowMs - (trackingStartedAtMs as number) : 0;
+  const silentTooLong = hasLastEmit
+    ? millisSinceLastEmit >= forceEmitAfterMs
+    : hasTrackingStart
+      ? millisSinceTrackingStart >= forceEmitAfterMs
+      : false;
+
+  const acceptedTimestamp = toIsoTimestamp(nowMs);
+
+  const acceptWithFreshTimestamp = (
+    reason: string,
+    sample: LocationEmitSample,
+    distanceMeters: number,
+    thresholdMeters: number
+  ): LocationStabilizeDecision => ({
+    shouldEmit: true,
+    reason,
+    sample: {
+      ...sample,
+      timestamp: acceptedTimestamp,
+    },
+    distanceMeters,
+    thresholdMeters,
+  });
+
+  const rejectDecision = (
+    reason: string,
+    sample: LocationEmitSample,
+    distanceMeters: number,
+    thresholdMeters: number
+  ): LocationStabilizeDecision => ({
+    shouldEmit: false,
+    reason,
+    sample,
+    distanceMeters,
+    thresholdMeters,
+  });
+
+  const normalizedIncoming: LocationEmitSample = {
+    ...incoming,
+    accuracy: normalizeAccuracy(incoming.accuracy),
+    timestamp: toIsoTimestamp(incoming.timestamp),
+  };
+
+  if (!hasValidCoordinate(normalizedIncoming.latitude, normalizedIncoming.longitude)) {
+    return rejectDecision("invalid_coordinates", previous || normalizedIncoming, 0, 0);
+  }
+
+  if (!previous) {
+    if (
+      normalizeAccuracy(normalizedIncoming.accuracy) !== undefined &&
+      (normalizedIncoming.accuracy as number) > MAX_ACCEPTABLE_ACCURACY_METERS
+    ) {
+      if (silentTooLong) {
+        return acceptWithFreshTimestamp("forced_initial_low_accuracy", normalizedIncoming, 0, 0);
+      }
+
+      return rejectDecision("poor_initial_accuracy", normalizedIncoming, 0, 0);
+    }
+
+    return acceptWithFreshTimestamp("initial_fix", normalizedIncoming, 0, 0);
+  }
+
+  const normalizedPrevious: LocationEmitSample = {
+    ...previous,
+    accuracy: normalizeAccuracy(previous.accuracy),
+    timestamp: toIsoTimestamp(previous.timestamp),
+  };
+
+  const distanceMeters = haversineDistanceMeters(
+    normalizedPrevious.latitude,
+    normalizedPrevious.longitude,
+    normalizedIncoming.latitude,
+    normalizedIncoming.longitude
+  );
+
+  const thresholdMeters = computeJitterThresholdMeters(
+    normalizedPrevious.accuracy,
+    normalizedIncoming.accuracy
+  );
+
+  const previousTs = new Date(normalizedPrevious.timestamp as string).getTime();
+  const incomingTs = new Date(normalizedIncoming.timestamp as string).getTime();
+  const deltaMs = incomingTs - previousTs;
+  const intervalSinceLastEmit = hasLastEmit ? millisSinceLastEmit : deltaMs;
+
+  if (deltaMs < -maxStaleNegativeSkewMs) {
+    if (silentTooLong) {
+      return acceptWithFreshTimestamp(
+        "forced_stale_source_keepalive",
+        {
+          ...normalizedPrevious,
+          accuracy:
+            normalizeAccuracy(normalizedPrevious.accuracy) ??
+            normalizeAccuracy(normalizedIncoming.accuracy),
+        },
+        distanceMeters,
+        thresholdMeters
+      );
+    }
+
+    return rejectDecision("stale_sample", normalizedPrevious, distanceMeters, thresholdMeters);
+  }
+
+  if (intervalSinceLastEmit < minEmitIntervalMs) {
+    return rejectDecision("rate_limited", normalizedPrevious, distanceMeters, thresholdMeters);
+  }
+
+  if (
+    normalizeAccuracy(normalizedIncoming.accuracy) !== undefined &&
+    (normalizedIncoming.accuracy as number) > MAX_ACCEPTABLE_ACCURACY_METERS &&
+    normalizeAccuracy(normalizedPrevious.accuracy) !== undefined &&
+    (normalizedPrevious.accuracy as number) <= (normalizedIncoming.accuracy as number)
+  ) {
+    if (silentTooLong) {
+      return acceptWithFreshTimestamp(
+        "forced_low_accuracy_keepalive",
+        {
+          ...normalizedPrevious,
+          accuracy:
+            normalizeAccuracy(normalizedPrevious.accuracy) ??
+            normalizeAccuracy(normalizedIncoming.accuracy),
+        },
+        distanceMeters,
+        thresholdMeters
+      );
+    }
+
+    return rejectDecision("poor_accuracy", normalizedPrevious, distanceMeters, thresholdMeters);
+  }
+
+  const incomingSpeed = isFiniteNumber(normalizedIncoming.speed)
+    ? Math.max(normalizedIncoming.speed, 0)
+    : 0;
+  const stationary = incomingSpeed <= STATIONARY_SPEED_THRESHOLD_MPS;
+  const stationaryMoveThresholdMeters = Math.max(MIN_STATIONARY_MOVE_METERS, thresholdMeters * 1.8);
+
+  if (stationary && distanceMeters <= stationaryMoveThresholdMeters) {
+    if (silentTooLong) {
+      return acceptWithFreshTimestamp(
+        "forced_stationary_keepalive",
+        {
+          ...normalizedPrevious,
+          accuracy:
+            normalizeAccuracy(normalizedPrevious.accuracy) ??
+            normalizeAccuracy(normalizedIncoming.accuracy),
+        },
+        distanceMeters,
+        thresholdMeters
+      );
+    }
+
+    return rejectDecision("stationary_jitter", normalizedPrevious, distanceMeters, thresholdMeters);
+  }
+
+  if (!stationary && distanceMeters < 1.2) {
+    if (silentTooLong) {
+      return acceptWithFreshTimestamp(
+        "forced_tiny_move_keepalive",
+        normalizedIncoming,
+        distanceMeters,
+        thresholdMeters
+      );
+    }
+
+    return rejectDecision("tiny_move", normalizedPrevious, distanceMeters, thresholdMeters);
+  }
+
+  if (stationary && distanceMeters <= MAX_SMOOTHING_DISTANCE_METERS) {
+    const smoothedSample: LocationEmitSample = {
+      ...normalizedIncoming,
+      latitude: weightedAverage(
+        normalizedPrevious.latitude,
+        normalizedIncoming.latitude,
+        normalizedPrevious.accuracy,
+        normalizedIncoming.accuracy
+      ),
+      longitude: weightedAverage(
+        normalizedPrevious.longitude,
+        normalizedIncoming.longitude,
+        normalizedPrevious.accuracy,
+        normalizedIncoming.accuracy
+      ),
+      accuracy:
+        normalizeAccuracy(normalizedIncoming.accuracy) ??
+        normalizeAccuracy(normalizedPrevious.accuracy),
+      timestamp: toIsoTimestamp(normalizedIncoming.timestamp),
+    };
+
+    return acceptWithFreshTimestamp("smoothed", smoothedSample, distanceMeters, thresholdMeters);
+  }
+
+  return acceptWithFreshTimestamp("accepted", normalizedIncoming, distanceMeters, thresholdMeters);
+};
diff --git a/Lifeline-Frontend/src/utils/filePicker.utils.ts b/Lifeline-Frontend/src/utils/filePicker.utils.ts
index 1896b22..8884a99 100644
--- a/Lifeline-Frontend/src/utils/filePicker.utils.ts
+++ b/Lifeline-Frontend/src/utils/filePicker.utils.ts
@@ -4,8 +4,8 @@ export const filePicker = async () => {
   let result = await ImagePicker.launchImageLibraryAsync({
     mediaTypes: ImagePicker.MediaTypeOptions.Images,
     allowsEditing: true,
-    aspect: [4, 3],
-    quality: 1,
+    aspect: [1, 1],
+    quality: 0.8,
   });
 
   return result;
diff --git a/Lifeline-Frontend/tsconfig.json b/Lifeline-Frontend/tsconfig.json
index dff398d..6e45a8c 100644
--- a/Lifeline-Frontend/tsconfig.json
+++ b/Lifeline-Frontend/tsconfig.json
@@ -3,6 +3,8 @@
   "compilerOptions": {
     "strict": true,
     "baseUrl": ".",
+    "moduleResolution": "bundler",
+    "lib": ["ES2020", "DOM"],
     "paths": {
       "@/*": ["./*"]
     }
diff --git a/ai-logs/Backend/.gitkeep b/ai-logs/Backend/.gitkeep
new file mode 100644
index 0000000..e69de29
diff --git a/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10-2026-03-10_17-54-21.md b/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10-2026-03-10_17-54-21.md
new file mode 100644
index 0000000..a1e009d
--- /dev/null
+++ b/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10-2026-03-10_17-54-21.md
@@ -0,0 +1,269 @@
+# Frontend Location Accuracy Change Log (2026-03-10)
+
+## Log Metadata
+
+- Log file: `logs/Frontend/frontend-location-accuracy-change-log-2026-03-10.md`
+- Category: Frontend SOS location accuracy + flow updates
+- Created on: 2026-03-10
+- Last updated: 2026-03-10 17:50:17 IST
+- Backend code changes: None (frontend-only implementation in this log)
+
+## 1. Scope
+
+This document records the frontend-only changes made to improve location quality, reduce jitter/noise, and keep location updates near a 5-second cadence during SOS tracking.
+
+Requested constraints:
+
+- Keep backend logic unchanged.
+- Improve frontend location reliability and update quality.
+- Continue sending location updates every 5 seconds with high accuracy mode.
+
+## 2. Files Added/Updated
+
+### Added
+
+- `Lifeline-Frontend/src/shared/utils/locationStabilizer.ts`
+
+### Updated
+
+- `Lifeline-Frontend/app/User/Dashboard.tsx`
+- `Lifeline-Frontend/src/shared/tasks/location.task.ts`
+
+### Backend
+
+- No backend code changes are part of this frontend accuracy update.
+
+## 3. Detailed Changes
+
+## 3.1 `src/shared/utils/locationStabilizer.ts` (new)
+
+Created a shared utility to decide whether a GPS fix should be emitted to backend.
+
+What it includes:
+
+- `LocationEmitSample` type
+- `LocationStabilizeDecision` type
+- `StabilizerConfig` options for runtime tuning
+- `haversineDistanceMeters(...)` helper
+- `stabilizeLocationUpdate(...)` core filter function
+
+Core filtering logic:
+
+- Reject invalid coordinates.
+- Reject only highly stale samples (large negative skew) to avoid false drops across source switches.
+- Reject too-frequent emits (`minEmitIntervalMs`, default ~4500ms).
+- Reject poor initial fix (`accuracy > 80m`).
+- Reject poor-quality updates that are worse than previous fix.
+- Reject stationary jitter (small movement while speed indicates stationary).
+- Smooth small stationary movement via weighted average.
+- Force keepalive emit after prolonged silence (default 15s) so SOS does not stay silent.
+
+Current thresholds:
+
+- `MAX_ACCEPTABLE_ACCURACY_METERS = 80`
+- `MIN_JITTER_THRESHOLD_METERS = 3`
+- `MAX_JITTER_THRESHOLD_METERS = 22`
+- `STATIONARY_SPEED_THRESHOLD_MPS = 0.8`
+- `MAX_SMOOTHING_DISTANCE_METERS = 35`
+- `MIN_STATIONARY_MOVE_METERS = 10`
+- `DEFAULT_FORCE_EMIT_AFTER_MS = 15000`
+- `DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS = 15000`
+
+Important behavior:
+
+- The function keeps payload shape unchanged (`latitude`, `longitude`, `accuracy`, etc.).
+- It only controls when and how a sample is emitted.
+- Accepted samples are stamped with a fresh processing timestamp to reduce cross-source stale conflicts.
+
+## 3.2 `app/User/Dashboard.tsx`
+
+Reworked foreground/background SOS location flow to prevent duplicate noisy updates.
+
+Changes made:
+
+- Added app state awareness (`AppState`, `AppStateStatus`).
+- Added refs:
+  - `lastForegroundLocationRef`
+  - `lastForegroundEmitAtRef`
+  - `appStateRef`
+  - `trackingSessionStartedAtRef`
+  - `foregroundPermissionGrantedRef`
+- Persisted role for background task:
+  - `AsyncStorage.setItem("user_role", userRole || "user")`
+- Updated foreground GPS call:
+  - Uses `Location.Accuracy.BestForNavigation`
+  - Adds `mayShowUserSettingsDialog: true`
+- Requests foreground permission once per active session (cached in ref) instead of each loop.
+- Added stabilization and rate-limiting before emit:
+  - Calls `stabilizeLocationUpdate(...)`
+  - Uses `minEmitIntervalMs: 4500`
+  - Passes `lastEmitAtMs`, `trackingStartedAtMs`, `forceEmitAfterMs`, `nowMs`
+- Added explicit foreground loop controls:
+  - `startForegroundLoop()`
+  - `stopForegroundLoop()`
+- Added mode switching by app state:
+  - App active -> foreground loop on, background tracking off
+  - App background/inactive -> foreground loop off, background tracking on
+- Background start options adjusted:
+  - Keeps `timeInterval: 5000`
+  - Uses `distanceInterval: 2` (from 1) to reduce tiny drift spam
+
+Result:
+
+- Prevents foreground and background updates from running in parallel most of the time.
+- Reduces duplicate emissions and jitter while keeping ~5s cadence.
+
+## 3.3 `src/shared/tasks/location.task.ts`
+
+Applied the same stabilization approach to background updates.
+
+Changes made:
+
+- Import shared stabilizer.
+- Added per-user caches:
+  - `lastBackgroundLocationByUser`
+  - `lastBackgroundEmitAtByUser`
+  - `backgroundTrackingStartedAtByUser`
+- Added minimum emit interval guard:
+  - `MIN_BACKGROUND_EMIT_INTERVAL_MS = 4500`
+- Uses normalized local processing timestamp for stability:
+  - `timestamp: new Date().toISOString()`
+- Runs `stabilizeLocationUpdate(...)` before emitting.
+- Passes fallback/timing metadata (`lastEmitAtMs`, `trackingStartedAtMs`, `forceEmitAfterMs`, `nowMs`).
+- Emits filtered/smoothed sample only.
+
+Result:
+
+- Background mode now sends fewer noisy updates.
+- Better consistency with foreground filtering rules.
+- If filtering suppresses updates for too long, keepalive fallback can still emit.
+
+## 4. Payload Contract to Backend
+
+Frontend still sends the same location payload shape:
+
+```json
+{
+  "userId": "...",
+  "role": "user",
+  "latitude": 24.0851,
+  "longitude": 85.8352,
+  "accuracy": 3.0,
+  "altitude": 347.1,
+  "speed": 0.0,
+  "heading": 182.1,
+  "timestamp": "2026-03-10T10:54:16.977Z"
+}
+```
+
+No field rename or contract-breaking change was introduced.
+
+## 5. Why Coordinates Can Still Differ Slightly
+
+Even with best possible frontend filtering:
+
+- Phone GNSS/GPS has natural drift.
+- Sensor fusion (GPS/Wi-Fi/cell) varies by environment.
+- Indoor/urban settings increase multipath errors.
+
+So "100% perfect static coordinates" is not physically guaranteed on mobile hardware.
+These changes reduce noise significantly, but cannot eliminate real-world GNSS drift entirely.
+
+## 6. Verification Performed
+
+Frontend checks run after the changes:
+
+- `pnpm exec eslint app/User/Dashboard.tsx src/shared/tasks/location.task.ts src/shared/utils/locationStabilizer.ts`
+- `pnpm exec tsc --noEmit`
+
+Outcome:
+
+- Lint clean on modified files.
+- Type check passed.
+- Backend untouched for this phase.
+
+## 7. Tuning Knobs (if stricter behavior is needed)
+
+Potential stricter adjustments:
+
+- Increase `MIN_STATIONARY_MOVE_METERS` from `10` to `12-15`.
+- Increase `MIN_BACKGROUND_EMIT_INTERVAL_MS` from `4500` to `5000-6000`.
+- Lower `MAX_ACCEPTABLE_ACCURACY_METERS` from `80` to `40-60` for very strict acceptance.
+- Increase `DEFAULT_FORCE_EMIT_AFTER_MS` from `15000` to `20000+` if keepalive emits feel too frequent.
+- Reduce `DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS` from `15000` if you want stricter stale rejection.
+
+These should be tuned based on real device tests in your deployment environment.
+
+## 8. Current Implementation Plan (Detailed)
+
+Phase A: Frontend Sensor Intake
+
+- Foreground (`Dashboard`) collects GPS using `BestForNavigation`.
+- Background (`location.task`) collects task manager updates.
+- Only one active mode runs per app state to reduce duplication.
+
+Phase B: Frontend Stabilization Decision
+
+- Raw sample is passed to `stabilizeLocationUpdate(...)`.
+- Decision computes movement, jitter threshold, speed-based stationary state, and timing context.
+- Decision returns `shouldEmit`, `reason`, and final `sample` (raw/smoothed/keepalive).
+
+Phase C: Emit Policy
+
+- Emit at approximately 5-second cadence with 4.5-second minimum guard.
+- Suppress stationary jitter and poor-quality updates.
+- Force keepalive emit if no accepted update for `15s` to avoid silent SOS periods.
+
+Phase D: Transport to Backend
+
+- Payload remains unchanged:
+  - `userId`, `role`, `latitude`, `longitude`, `accuracy`, `altitude`, `speed`, `heading`, `timestamp`
+- No backend contract changes required.
+
+Phase E: Operational Validation
+
+- Verify in three scenarios:
+  - Stationary outdoor.
+  - Walking or driving.
+  - Foreground/background app transitions.
+- Track emit reasons in logs (`initial_fix`, `smoothed`, `stationary_jitter`, `forced_*`).
+
+Phase F: Next Hardening (Optional)
+
+- Add dedicated unit tests once a frontend test runner (Jest/Vitest) is configured.
+- Add runtime counters for suppressed vs emitted points to aid threshold tuning.
+
+## 9. Documentation Sync Log (Detailed)
+
+This section tracks where the same flow was documented so all references stay consistent.
+
+### 9.1 Updated Documentation Files
+
+- `Backend Architecture & Integration_Guide.md`
+- `implementation_plan.md`
+- `LifeLine-Backend/docs/04-Business-Logic-and-Rules.md`
+- `LifeLine-Backend/docs/11-Socket-Protocol.md`
+- `LifeLine-Backend/docs/16-Backend-Features-Guide.md`
+- `LifeLine-Backend/docs/20-End-to-End-Workflows.md`
+- `LifeLine-Backend/src/socket/SOCKET_API.md`
+
+### 9.2 What Was Updated in Those Docs
+
+- Replaced old/unclear location wording with current behavior.
+- Standardized update cadence wording to near 5 seconds.
+- Documented that app uses one tracking mode at a time:
+  - foreground when app is active
+  - background task when app is inactive/background
+- Documented frontend filtering behavior:
+  - invalid/stale drop
+  - minimum interval guard (~4.5s)
+  - stationary jitter suppression
+  - keepalive fallback after prolonged silence
+- Clarified location socket events and payload usage.
+- Kept backend contract note explicit: payload shape unchanged.
+
+### 9.3 Final State Summary
+
+- Source of truth for frontend location changes: this file.
+- Source of truth for event names/payloads: `LifeLine-Backend/docs/11-Socket-Protocol.md` and `LifeLine-Backend/src/socket/SOCKET_API.md`.
+- Current status: docs aligned with implemented frontend flow as of 2026-03-10.
diff --git a/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10.md b/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10.md
new file mode 100644
index 0000000..ba243c1
--- /dev/null
+++ b/ai-logs/Frontend/frontend-location-accuracy-change-log-2026-03-10.md
@@ -0,0 +1,226 @@
+# Frontend Location Accuracy Change Log (2026-03-10)
+
+## 1. Scope
+
+This document records the frontend-only changes made to improve location quality, reduce jitter/noise, and keep location updates near a 5-second cadence during SOS tracking.
+
+Requested constraints:
+
+- Keep backend logic unchanged.
+- Improve frontend location reliability and update quality.
+- Continue sending location updates every 5 seconds with high accuracy mode.
+
+## 2. Files Added/Updated
+
+### Added
+
+- `Lifeline-Frontend/src/shared/utils/locationStabilizer.ts`
+
+### Updated
+
+- `Lifeline-Frontend/app/User/Dashboard.tsx`
+- `Lifeline-Frontend/src/shared/tasks/location.task.ts`
+
+### Backend
+
+- No backend code changes are part of this frontend accuracy update.
+
+## 3. Detailed Changes
+
+## 3.1 `src/shared/utils/locationStabilizer.ts` (new)
+
+Created a shared utility to decide whether a GPS fix should be emitted to backend.
+
+What it includes:
+
+- `LocationEmitSample` type
+- `LocationStabilizeDecision` type
+- `StabilizerConfig` options for runtime tuning
+- `haversineDistanceMeters(...)` helper
+- `stabilizeLocationUpdate(...)` core filter function
+
+Core filtering logic:
+
+- Reject invalid coordinates.
+- Reject only highly stale samples (large negative skew) to avoid false drops across source switches.
+- Reject too-frequent emits (`minEmitIntervalMs`, default ~4500ms).
+- Reject poor initial fix (`accuracy > 80m`).
+- Reject poor-quality updates that are worse than previous fix.
+- Reject stationary jitter (small movement while speed indicates stationary).
+- Smooth small stationary movement via weighted average.
+- Force keepalive emit after prolonged silence (default 15s) so SOS does not stay silent.
+
+Current thresholds:
+
+- `MAX_ACCEPTABLE_ACCURACY_METERS = 80`
+- `MIN_JITTER_THRESHOLD_METERS = 3`
+- `MAX_JITTER_THRESHOLD_METERS = 22`
+- `STATIONARY_SPEED_THRESHOLD_MPS = 0.8`
+- `MAX_SMOOTHING_DISTANCE_METERS = 35`
+- `MIN_STATIONARY_MOVE_METERS = 10`
+- `DEFAULT_FORCE_EMIT_AFTER_MS = 15000`
+- `DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS = 15000`
+
+Important behavior:
+
+- The function keeps payload shape unchanged (`latitude`, `longitude`, `accuracy`, etc.).
+- It only controls when and how a sample is emitted.
+- Accepted samples are stamped with a fresh processing timestamp to reduce cross-source stale conflicts.
+
+## 3.2 `app/User/Dashboard.tsx`
+
+Reworked foreground/background SOS location flow to prevent duplicate noisy updates.
+
+Changes made:
+
+- Added app state awareness (`AppState`, `AppStateStatus`).
+- Added refs:
+  - `lastForegroundLocationRef`
+  - `lastForegroundEmitAtRef`
+  - `appStateRef`
+  - `trackingSessionStartedAtRef`
+  - `foregroundPermissionGrantedRef`
+- Persisted role for background task:
+  - `AsyncStorage.setItem("user_role", userRole || "user")`
+- Updated foreground GPS call:
+  - Uses `Location.Accuracy.BestForNavigation`
+  - Adds `mayShowUserSettingsDialog: true`
+- Requests foreground permission once per active session (cached in ref) instead of each loop.
+- Added stabilization and rate-limiting before emit:
+  - Calls `stabilizeLocationUpdate(...)`
+  - Uses `minEmitIntervalMs: 4500`
+  - Passes `lastEmitAtMs`, `trackingStartedAtMs`, `forceEmitAfterMs`, `nowMs`
+- Added explicit foreground loop controls:
+  - `startForegroundLoop()`
+  - `stopForegroundLoop()`
+- Added mode switching by app state:
+  - App active -> foreground loop on, background tracking off
+  - App background/inactive -> foreground loop off, background tracking on
+- Background start options adjusted:
+  - Keeps `timeInterval: 5000`
+  - Uses `distanceInterval: 2` (from 1) to reduce tiny drift spam
+
+Result:
+
+- Prevents foreground and background updates from running in parallel most of the time.
+- Reduces duplicate emissions and jitter while keeping ~5s cadence.
+
+## 3.3 `src/shared/tasks/location.task.ts`
+
+Applied the same stabilization approach to background updates.
+
+Changes made:
+
+- Import shared stabilizer.
+- Added per-user caches:
+  - `lastBackgroundLocationByUser`
+  - `lastBackgroundEmitAtByUser`
+  - `backgroundTrackingStartedAtByUser`
+- Added minimum emit interval guard:
+  - `MIN_BACKGROUND_EMIT_INTERVAL_MS = 4500`
+- Uses normalized local processing timestamp for stability:
+  - `timestamp: new Date().toISOString()`
+- Runs `stabilizeLocationUpdate(...)` before emitting.
+- Passes fallback/timing metadata (`lastEmitAtMs`, `trackingStartedAtMs`, `forceEmitAfterMs`, `nowMs`).
+- Emits filtered/smoothed sample only.
+
+Result:
+
+- Background mode now sends fewer noisy updates.
+- Better consistency with foreground filtering rules.
+- If filtering suppresses updates for too long, keepalive fallback can still emit.
+
+## 4. Payload Contract to Backend
+
+Frontend still sends the same location payload shape:
+
+```json
+{
+  "userId": "...",
+  "role": "user",
+  "latitude": 24.0851,
+  "longitude": 85.8352,
+  "accuracy": 3.0,
+  "altitude": 347.1,
+  "speed": 0.0,
+  "heading": 182.1,
+  "timestamp": "2026-03-10T10:54:16.977Z"
+}
+```
+
+No field rename or contract-breaking change was introduced.
+
+## 5. Why Coordinates Can Still Differ Slightly
+
+Even with best possible frontend filtering:
+
+- Phone GNSS/GPS has natural drift.
+- Sensor fusion (GPS/Wi-Fi/cell) varies by environment.
+- Indoor/urban settings increase multipath errors.
+
+So "100% perfect static coordinates" is not physically guaranteed on mobile hardware.
+These changes reduce noise significantly, but cannot eliminate real-world GNSS drift entirely.
+
+## 6. Verification Performed
+
+Frontend checks run after the changes:
+
+- `pnpm exec eslint app/User/Dashboard.tsx src/shared/tasks/location.task.ts src/shared/utils/locationStabilizer.ts`
+- `pnpm exec tsc --noEmit`
+
+Outcome:
+
+- Lint clean on modified files.
+- Type check passed.
+- Backend untouched for this phase.
+
+## 7. Tuning Knobs (if stricter behavior is needed)
+
+Potential stricter adjustments:
+
+- Increase `MIN_STATIONARY_MOVE_METERS` from `10` to `12-15`.
+- Increase `MIN_BACKGROUND_EMIT_INTERVAL_MS` from `4500` to `5000-6000`.
+- Lower `MAX_ACCEPTABLE_ACCURACY_METERS` from `80` to `40-60` for very strict acceptance.
+- Increase `DEFAULT_FORCE_EMIT_AFTER_MS` from `15000` to `20000+` if keepalive emits feel too frequent.
+- Reduce `DEFAULT_MAX_STALE_NEGATIVE_SKEW_MS` from `15000` if you want stricter stale rejection.
+
+These should be tuned based on real device tests in your deployment environment.
+
+## 8. Current Implementation Plan (Detailed)
+
+Phase A: Frontend Sensor Intake
+
+- Foreground (`Dashboard`) collects GPS using `BestForNavigation`.
+- Background (`location.task`) collects task manager updates.
+- Only one active mode runs per app state to reduce duplication.
+
+Phase B: Frontend Stabilization Decision
+
+- Raw sample is passed to `stabilizeLocationUpdate(...)`.
+- Decision computes movement, jitter threshold, speed-based stationary state, and timing context.
+- Decision returns `shouldEmit`, `reason`, and final `sample` (raw/smoothed/keepalive).
+
+Phase C: Emit Policy
+
+- Emit at approximately 5-second cadence with 4.5-second minimum guard.
+- Suppress stationary jitter and poor-quality updates.
+- Force keepalive emit if no accepted update for `15s` to avoid silent SOS periods.
+
+Phase D: Transport to Backend
+
+- Payload remains unchanged:
+  - `userId`, `role`, `latitude`, `longitude`, `accuracy`, `altitude`, `speed`, `heading`, `timestamp`
+- No backend contract changes required.
+
+Phase E: Operational Validation
+
+- Verify in three scenarios:
+  - Stationary outdoor.
+  - Walking or driving.
+  - Foreground/background app transitions.
+- Track emit reasons in logs (`initial_fix`, `smoothed`, `stationary_jitter`, `forced_*`).
+
+Phase F: Next Hardening (Optional)
+
+- Add dedicated unit tests once a frontend test runner (Jest/Vitest) is configured.
+- Add runtime counters for suppressed vs emitted points to aid threshold tuning.
diff --git a/docs/ai-triage-sos-hld-lld.md b/docs/ai-triage-sos-hld-lld.md
new file mode 100644
index 0000000..4de77e0
--- /dev/null
+++ b/docs/ai-triage-sos-hld-lld.md
@@ -0,0 +1,140 @@
+# AI Triage → SOS Integration HLD & LLD
+
+This document defines the high-level and low-level design for integrating AI triage with SOS creation, including fast‑track critical escalation, schema validation, and session handling.
+
+## HLD
+
+### Goals
+- Use AI triage to decide when to create SOS.
+- Fast-track critical symptoms with `priority=critical`.
+- Validate AI output against a JSON schema and fallback to `need_more_info`.
+- Keep the existing emergency flow intact and reuse current SOS logic.
+
+### Scope
+- AI triage decision → SOS creation link.
+- Critical symptom routing to high-priority SOS.
+- Output schema validation with safe fallback.
+- Session storage (in-memory for dev, Redis for production).
+
+### Non-Goals
+- Replacing existing emergency create/resolve APIs.
+- Full AI analytics dashboard.
+- Rewriting existing socket protocol.
+
+### System Components
+- **Frontend**: Triage chat screen, SOS status screen.
+- **Backend**: Triage service, Emergency service, Notification service.
+- **Storage**: Triage session store (Redis).
+- **Realtime**: Socket events for triage lifecycle and SOS creation.
+
+### Data Flow Overview
+1. User opens AI triage and starts a session.
+2. AI asks questions and collects symptoms and context.
+3. AI returns a structured decision object.
+4. If decision is `create_emergency`, backend calls `EmergencyService.triggerSOS`.
+5. SOS is created with `priority=critical` if critical flags exist.
+6. Helper assignment proceeds using existing SOS logic.
+7. Frontend transitions from AI triage to SOS status screen and listens for helper updates.
+
+### Security & Access
+- Auth required for triage and SOS.
+- SOS creation is tied to the triage session owner.
+- AI output is validated before any emergency creation.
+
+### Risks & Mitigations
+- **AI output malformed** → schema validation + fallback to `need_more_info`.
+- **False positives** → require minimum confidence or critical symptom gate.
+- **Latency** → cache session state and reduce prompt size.
+- **AI unresponsive** → return safe error and allow manual SOS.
+
+---
+
+## LLD
+
+### Data Models
+
+#### Triage Session (in-memory / Redis)
+- sessionId
+- userId
+- status: `active` | `resolved` | `expired`
+- messages[]
+- extractedInfo
+- decision
+- severity
+- emergencyPayload
+- createdAt, updatedAt
+
+#### AI Decision Output (Schema)
+```json
+{
+  "decision": "create_emergency | need_more_info | no_emergency",
+  "severity": "critical | high | medium | low",
+  "symptoms": ["string"],
+  "title": "string",
+  "description": "string",
+  "type": "medical | accident | fire | crime | other",
+  "followUpQuestion": "string | null"
+}
+```
+
+### APIs
+
+#### POST /api/triage/start
+- Body: { location, language, emergencyType }
+- Behavior: create session and return sessionId with first AI question.
+- Response: { sessionId, question }
+
+#### POST /api/triage/message
+- Body: { sessionId, message }
+- Behavior: append user message, query AI, validate response schema.
+- Response:
+  - `need_more_info`: { question }
+  - `create_emergency`: { emergencyId, emergencyData, emergencyCreated }
+  - `no_emergency`: { guidance }
+
+### Service Logic
+
+#### triageService.processMessage
+1. Load session by sessionId.
+2. Add user message.
+3. Call AI with conversation state.
+4. Validate response against schema.
+5. If invalid → set decision `need_more_info`.
+6. If decision is `create_emergency`:
+   - Map AI fields to SOS payload.
+   - If severity is `critical`, enforce `priority=critical`.
+   - Call `EmergencyService.triggerSOS`.
+   - Emit `triage:emergency_created`.
+7. Persist session state.
+
+#### EmergencyService.triggerSOS (existing)
+- Reused for SOS creation and helper assignment.
+
+### Critical Fast‑Track Rules
+- If severity is `critical` or symptoms include:
+  - unconsciousness
+  - severe bleeding
+  - breathing difficulty
+  - chest pain
+  - stroke signs
+- Force `priority=critical` and `settings.autoAssignHelpers=true`.
+
+### Socket Events
+- `triage:session_started`
+- `triage:ai_response`
+- `triage:emergency_decision`
+- `triage:emergency_created`
+- `emergency:helper_assigned`
+- `emergency:helper_accepted`
+- `emergency:helper_arrived`
+
+### Frontend Flow
+- User opens AI triage and completes assessment.
+- On `create_emergency`, auto-navigate to SOS status screen.
+- SOS status screen listens for helper events and updates UI.
+
+### Testing Checklist
+- Decision → create_emergency triggers SOS.
+- Critical symptoms force priority=critical.
+- Invalid AI output falls back to need_more_info.
+- Session expired returns safe error and restarts triage.
diff --git a/docs/codebase-risk-assessment.md b/docs/codebase-risk-assessment.md
new file mode 100644
index 0000000..1a7cb6e
--- /dev/null
+++ b/docs/codebase-risk-assessment.md
@@ -0,0 +1,29 @@
+# Codebase Risk Assessment (LifeLine)
+
+Date: 2026-03-10
+Scope: Backend, Frontend, and Documentation
+Method: Static review of code paths and configuration. No runtime tests executed.
+
+## Executive Summary
+
+This assessment is split into subsystem reports:
+- `docs/risk-assessment-backend.md`
+- `docs/risk-assessment-frontend.md`
+- `docs/risk-assessment-doc-mismatches.md`
+
+## Top Critical/High Risks (Consolidated)
+
+1. Auth vulnerabilities: password reset plaintext storage, check-email token issuance, and unverified social login (backend).
+2. Missing auth/authorization on several REST and socket paths (backend).
+3. Socket impersonation and unauthorized subscriptions (backend).
+4. Helper assignment ID mismatch in socket SOS flow (backend).
+5. Location/medical/payment endpoints allow cross-user access (backend).
+6. Frontend uses `check-email` as a login path when tokens are returned (frontend).
+7. Notifications UI calls a non-existent endpoint (frontend).
+8. Client-side Sarvam API usage uses non-public keys (frontend).
+
+## Next Steps
+
+- Follow the “Suggested Fix Order” in the backend report to reduce attack surface first.
+- Align frontend auth flows with backend security fixes.
+- Regenerate stale API mismatch docs once code changes land.
diff --git a/docs/future-implementation-summary.md b/docs/future-implementation-summary.md
new file mode 100644
index 0000000..92393ac
--- /dev/null
+++ b/docs/future-implementation-summary.md
@@ -0,0 +1,80 @@
+# Future Implementation Summary
+
+This document consolidates the future work items across AI, Socket, SOS upgrade, and product roadmap. It is meant to guide sequencing and ownership without duplicating the full detailed plans in the backend docs.
+
+## 1) SOS Upgrade (Payments, OTP, Profiles)
+- Add missing schema fields for helper and emergency (payment status, service type, accepted helpers).
+- Introduce a dedicated Payment collection for paid/free flow.
+- Implement SOS profile API for helpers to view user medical snapshot and history.
+- Complete paid/free acceptance, approval, OTP verification, and release flow.
+- Expand helper stats API to include earnings, paid vs free, and performance metrics.
+
+Primary references:
+- LifeLine-Backend/docs/future-implementation.md
+- LifeLine-Backend/docs/21-SOS-Upgrade-Status-and-Plan.md
+
+## 2) AI Triage → SOS Integration
+- Auto-create SOS when AI decision is create_emergency.
+- Standardize fast-track for critical symptoms with priority=critical.
+- Enforce JSON schema validation with fallback to need_more_info.
+- Move session storage to Redis for production reliability.
+
+Primary references:
+- LifeLine-Backend/src/Ai/triage/triageService.mjs
+- LifeLine-Backend/src/Ai/LifeLine_AI_SOS_Implementation_Plan_UPDATED.md
+
+## 3) Triage Group Alerts + Multi-Channel Dispatch
+- AI should output recipient groups (guardians, nearby helpers, NGOs, hospitals).
+- Map groups to actual recipients in DB before dispatch.
+- Socket rooming for user, emergency, and optional group rooms.
+- Use push/SMS/email for offline users with persisted notifications.
+
+Primary references:
+- LifeLine-Backend/docs/11-Socket-Protocol.md
+- LifeLine-Backend/docs/future-features-design.md
+
+## 4) Context-Aware Helper Assignment
+- Map emergency context to helper skill categories.
+- Extend helper matching to filter by skills and language.
+- Prioritize specialized helpers with fallback to general helpers.
+
+Primary references:
+- LifeLine-Backend/docs/future-implementation.md
+
+## 5) Socket Expansion + Reliability
+- Complete missing socket events across user/helper/NGO flows.
+- Add delivery acknowledgements, reconnect replay, and dedupe.
+- Add rate limits, backpressure, and payload caps.
+- Introduce Redis adapter for scaling.
+
+Primary references:
+- LifeLine-Backend/docs/11-Socket-Protocol.md
+- technical_implementation_plan.md
+
+## 6) Frontend Completion & Integration
+- Complete missing screens: NGO dashboards, helper history, medical CRUD.
+- Wire all backend NGO, payment, and notification flows.
+- Add socket middleware handling for real-time updates.
+- Add profile completion checklists and error/loading states.
+
+Primary references:
+- technical_implementation_plan.md
+- implementation_plan.md
+
+## 7) Testing, Monitoring, and Operations
+- End-to-end flows for SOS, helper acceptance, and triage.
+- AI cost monitoring and safety dashboards.
+- Delivery metrics for notifications and socket events.
+- Runbooks and incident response playbooks.
+
+Primary references:
+- LifeLine-Backend/docs/07-Testing-Strategy.md
+- LifeLine-Backend/docs/08-Deployment-and-Ops.md
+
+## Suggested Sequencing
+1. SOS upgrade payment + OTP end-to-end.
+2. AI triage auto-create + critical fast-track.
+3. Triage group alerts + multi-channel dispatch.
+4. Socket reliability + Redis scaling.
+5. Frontend integrations for NGO, helper, and medical CRUD.
+6. Monitoring and production hardening.
diff --git a/docs/risk-assessment-backend.md b/docs/risk-assessment-backend.md
new file mode 100644
index 0000000..cd901a0
--- /dev/null
+++ b/docs/risk-assessment-backend.md
@@ -0,0 +1,209 @@
+# Backend Risk Assessment (LifeLine)
+
+Date: 2026-03-10
+Scope: `LifeLine-Backend`
+Method: Static review of code paths, schemas, routes, and socket handlers. No runtime tests executed.
+
+## Severity Key
+- Critical: Likely to cause security breach, data loss, or core feature failure.
+- High: Breaks important flows or introduces significant security/availability risk.
+- Medium: Breaks edge cases or causes degraded behavior under load.
+- Low: Quality, maintainability, or future risk with limited immediate impact.
+
+## Critical Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| B-C-01 | Critical | `src/api/Auth/v1/Auth.service.mjs`, `src/api/Auth/v1/Auth.model.mjs` | Password reset/change stores plaintext passwords and uses OTP fields missing from schema, breaking login and risking plaintext storage. | Any password reset/change. | Add OTP fields or use existing reset token fields; always hash new passwords. |
+| B-C-02 | Critical | `src/api/Auth/v1/Auth.service.mjs`, `src/api/Auth/v1/Auth.controller.mjs` | Email check returns tokens without authentication, enabling account takeover with just an email address. | Any unauthenticated check-email call. | Remove token issuance from email existence check. |
+| B-C-03 | Critical | `src/api/Auth/v1/Auth.controller.mjs`, `src/api/Auth/v1/Auth.service.mjs` | Social login accepts unverified provider data; anyone can forge profiles. | Any social login. | Verify provider tokens server-side and fetch profiles from provider APIs. |
+| B-C-04 | Critical | `src/api/User/User.routes.mjs`, `src/api/Helper/Helper.routes.mjs` | Most user/helper routes are public; any client can mutate profiles. | Any unauthenticated request. | Enforce auth + role checks on all state-changing routes. |
+| B-C-05 | Critical | `src/socket/*` | Socket registration trusts client-provided `userId`, enabling impersonation and unauthorized subscriptions. | Any malicious client. | Require JWT auth on socket handshake and bind identity server-side. |
+| B-C-06 | Critical | `src/api/User/v1/User.Schema.mjs`, `src/api/User/User.service.mjs` | User schema missing fields used by services; Mongoose drops data, breaking profile completion. | Any user create/update. | Align schema or refactor services to use Auth as source. |
+| B-C-07 | Critical | `src/socket/handlers/emergency.handler.mjs`, `src/api/Emergency/Emergency.model.mjs` | Socket SOS assigns Helper profile IDs into Auth-ID field, breaking acceptance and arrival flows. | Socket-triggered SOS flow. | Store helper Auth IDs consistently (or change schema + services). |
+
+## High Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| B-H-01 | High | `src/server.mjs`, `src/api/Auth/v1/Auth.middleware.mjs`, `src/config/socket.config.mjs` | CORS allows wildcard origins with credentials; unsafe and invalid for browser cookies. | Credentialed browser requests. | Use explicit allowlist and avoid `*` with credentials. |
+| B-H-02 | High | `src/api/Auth/v1/Auth.controller.mjs` | Cookies set to an object and without secure flags; breaks cookie auth. | Signup/login. | Store token string only and set `httpOnly`, `secure`, `sameSite`. |
+| B-H-03 | High | `src/api/Auth/v1/Auth.middleware.mjs`, `src/api/Auth/v1/Auth.controller.mjs` | Logs expose tokens/passwords/OTP. | Any auth flow. | Remove or redact sensitive logs. |
+| B-H-04 | High | `src/api/Payment/Payment.routes.mjs`, `src/api/Payment/Payment.controller.mjs` | Payment release lacks ownership checks. Any auth user can release arbitrary payments. | Any authenticated request with a payment ID. | Enforce ownership/role and state checks. |
+| B-H-05 | High | `src/api/Location/Location.controller.mjs`, `src/api/Location/Location.routes.mjs` | Location endpoints allow cross-user reads/updates by ID. | Any authenticated request. | Enforce ownership checks and limit cross-user access. |
+| B-H-06 | High | `src/api/Medical/Medical.controller.mjs`, `src/api/Medical/Medical.routes.mjs` | Medical endpoints allow cross-user access by ID, exposing PHI. | Any authenticated request. | Enforce ownership/role checks for medical data. |
+| B-H-07 | High | `src/socket/handlers/emergency.handler.mjs` | Emergency socket join/respond lacks authorization; responses can be spoofed. | Any socket client with an emergency ID. | Validate membership/assignment server-side. |
+| B-H-08 | High | `src/server.mjs` | `/uploads` is publicly served; profile images/PII are exposed without auth. | Any unauthenticated request to `/uploads`. | Serve via signed URLs or auth-protected routes. |
+| B-H-09 | High | `src/api/NGO/NGO.routes.mjs`, `src/api/NGO/NGO.controller.mjs` | NGO payments can be created/updated without ownership checks. | Any authenticated request. | Validate NGO ownership and enforce roles. |
+| B-H-10 | High | `src/api/User/User.routes.mjs`, `src/api/Helper/Helper.routes.mjs`, `src/api/Location/Location.routes.mjs` | Route ordering puts `/:id` before static paths, making specific routes unreachable. | Requests to `/profile/me`, `/user/:userId`, etc. | Reorder routes (static before param). |
+
+## Medium Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| B-M-01 | Medium | `src/api/Emergency/Emergency.model.mjs` | `resolvedAt` and duration metrics are not stored; stats are wrong. | Stats or SLA reporting. | Persist `resolvedAt` and duration metrics. |
+| B-M-02 | Medium | `src/api/Emergency/Emergency.service.mjs` | Guardian lookup filters `Auth.isActive`, which does not exist. | Guardian alert flow. | Remove filter or add field. |
+| B-M-03 | Medium | `src/api/Auth/v1/Auth.service.mjs` | OTP returned in API response, negating security. | Password reset. | Never return OTP in API response. |
+| B-M-04 | Medium | `src/api/Auth/v1/Auth.middleware.mjs` | Custom in-memory rate limiter is unbounded and O(n). | High traffic/abuse. | Use a tested limiter with TTL/LRU and shared storage. |
+| B-M-05 | Medium | `src/api/Location/Location.service.mjs` | Location history queries use profile IDs but controllers pass Auth IDs. | Location history/stats. | Normalize IDs or convert Auth → profile. |
+| B-M-06 | Medium | `src/api/Notifications/v1/Notification.model.mjs`, `src/socket/handlers/emergency.handler.mjs` | Notifications store Auth IDs in User-ref fields; channels default assumptions can throw. | Notification queries/population. | Standardize ID type and set robust defaults. |
+| B-M-07 | Medium | `src/api/Location/Location.utils.mjs` | Uses global `fetch` without timeout/retry; Node <18 breaks. | Older Node or slow geocoder. | Add timeout/retry or require Node >=18. |
+| B-M-08 | Medium | `src/config/socket.config.mjs` | One socket per user; multi-device overwrites and disconnects break state. | Multi-device login. | Store multiple sockets per user. |
+| B-M-09 | Medium | `src/api/Location/Location.model.mjs` | `placeType` enum lacks `'current'` but service writes it. | Current-location updates. | Add `'current'` or avoid writing it. |
+| B-M-10 | Medium | `src/api/Emergency/Emergency.service.mjs` | `triggerSOS` forces type to `medical`, ignoring triage inputs. | Triage or force-emergency. | Respect incoming type/priority. |
+| B-M-11 | Medium | `src/Ai/triage/triageSession.mjs` | Redis `KEYS` scan is O(n) and blocks at scale. | Many active sessions. | Use indexed mapping (user → session). |
+| B-M-12 | Medium | `src/Ai/triage/triageSession.mjs` | In-memory sessions are lost on restart. | Process restarts. | Persist sessions or document behavior. |
+| B-M-13 | Medium | `src/api/Payment/Payment.controller.mjs` | Payment creation does not validate ownership/authorization. | Any authenticated user. | Validate emergency ownership and helper assignment. |
+| B-M-14 | Medium | `src/api/Auth/v1/Auth.service.mjs` | Refresh tokens are not stored/revoked; logout is stateless. | Token theft or logout expectations. | Implement token revocation/rotation. |
+| B-M-15 | Medium | `src/utils/multer.utils.mjs` | File type checks rely on client-provided mimetype; spoofing is possible. | Malicious file upload. | Validate by file signature/magic bytes. |
+| B-M-16 | Medium | `src/socket/handlers/notification.handler.mjs` | Socket notification read/unread is not persisted; can drift from REST. | Mixed socket/REST usage. | Persist read state or remove socket-only APIs. |
+| B-M-17 | Medium | `src/api/Emergency/Emergency.model.mjs` | TTL deletes emergencies after 24h; audit/history lost. | Long-lived cases or audits. | Extend TTL or archive instead of delete. |
+| B-M-18 | Medium | `src/api/Medical/Medical.controller.mjs` | `/:id` route is treated as userId, not medicalId. | Client uses medicalId. | Clarify semantics or add distinct routes. |
+| B-M-19 | Medium | `src/api/Medical/v1/Medical.Schema.mjs` | `userId` ref expects `User`, but services store Auth IDs. | Medical lookup and population. | Standardize ID type. |
+| B-M-20 | Medium | `src/api/NGO/NGO.routes.mjs` | Admin role is not defined in Auth roles; admin endpoints may be unusable. | Admin management. | Add admin role or adjust authorization. |
+
+## Low Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| B-L-01 | Low | `src/api/User/v1/User.Schema.mjs`, `src/api/Helper/Helper.model.mjs` | Indexes reference non-existent fields. | Index build time. | Remove or correct indexes. |
+| B-L-02 | Low | `src/server.mjs`, `src/api/Auth/v1/Auth.middleware.mjs` | Debug logs in production paths. | Production logs. | Gate logs with env flags. |
+| B-L-03 | Low | `src/config/mongo.config.mjs` | Creates index on `locationsTree` collection which is not used by the app. | Startup and DB indexes. | Remove or point to correct collection. |
+| B-L-04 | Low | `src/api/HelpRequest/v1/*.mjs` | Empty placeholder modules; features are incomplete. | Future imports/use. | Implement or remove placeholders. |
+| B-L-05 | Low | `src/api/Helper/Helper.service.mjs` | Dashboard metrics include hardcoded placeholders (online time/weekly growth). | Analytics accuracy. | Implement real tracking or label as mock. |
+
+## Per-File Appendix
+
+| File | Review Status | Issue IDs / Notes |
+|---|---|---|
+| `LifeLine-Backend/Dockerfile` | No issues found | - |
+| `LifeLine-Backend/docker-compose.yml` | No issues found | - |
+| `LifeLine-Backend/docs/01-System-Overview.md` | No issues found | - |
+| `LifeLine-Backend/docs/02-Architecture-Design.md` | No issues found | - |
+| `LifeLine-Backend/docs/03-Features-and-Roadmap.md` | No issues found | - |
+| `LifeLine-Backend/docs/04-Business-Logic-and-Rules.md` | No issues found | - |
+| `LifeLine-Backend/docs/05-Getting-Started.md` | No issues found | - |
+| `LifeLine-Backend/docs/06-Development-Workflow.md` | No issues found | - |
+| `LifeLine-Backend/docs/07-Testing-Strategy.md` | No issues found | - |
+| `LifeLine-Backend/docs/08-Deployment-and-Ops.md` | No issues found | - |
+| `LifeLine-Backend/docs/09-API-Reference.md` | No issues found | - |
+| `LifeLine-Backend/docs/10-Database-Schema.md` | No issues found | - |
+| `LifeLine-Backend/docs/11-Socket-Protocol.md` | No issues found | - |
+| `LifeLine-Backend/docs/12-AI-System-Spec.md` | No issues found | - |
+| `LifeLine-Backend/docs/13-API-Examples.md` | No issues found | - |
+| `LifeLine-Backend/docs/14-Local-Setup.md` | No issues found | - |
+| `LifeLine-Backend/docs/15-AI-Triage-System.md` | No issues found | - |
+| `LifeLine-Backend/docs/16-Backend-Features-Guide.md` | No issues found | - |
+| `LifeLine-Backend/docs/17-Postman-Testing-Flow.md` | No issues found | - |
+| `LifeLine-Backend/docs/18-Public-Access-Guide.md` | No issues found | - |
+| `LifeLine-Backend/docs/20-End-to-End-Workflows.md` | No issues found | - |
+| `LifeLine-Backend/docs/21-SOS-Upgrade-Status-and-Plan.md` | No issues found | - |
+| `LifeLine-Backend/docs/22-Postman-Implemented-Endpoints.md` | No issues found | - |
+| `LifeLine-Backend/docs/api-mismatch-report.md` | No issues found | - |
+| `LifeLine-Backend/docs/future-features-design.md` | No issues found | - |
+| `LifeLine-Backend/docs/future-implementation.md` | No issues found | - |
+| `LifeLine-Backend/docs/updated-app-workflow.md` | No issues found | - |
+| `LifeLine-Backend/docs/user-helperconflict.md` | No issues found | - |
+| `LifeLine-Backend/jest.config.mjs` | No issues found | - |
+| `LifeLine-Backend/package.json` | No issues found | - |
+| `LifeLine-Backend/pnpm-lock.yaml` | No issues found | - |
+| `LifeLine-Backend/src/Ai/LifeLine_AI_SOS_Implementation_Plan_UPDATED.md` | No issues found | - |
+| `LifeLine-Backend/src/Ai/Prompt/LifeLine_AI_Emergency_Triage.txt` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/index.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triage.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triage.controller.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triage.routes.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triagePrompts.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triageService.mjs` | No issues found | - |
+| `LifeLine-Backend/src/Ai/triage/triageSession.mjs` | Issues found | B-M-11, B-M-12 |
+| `LifeLine-Backend/src/Ai/triage/triageState.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/Auth.Implementation_Plan.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/README.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.controller.mjs` | Issues found | B-C-02, B-C-03, B-H-02, B-H-03 |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.middleware.mjs` | Issues found | B-H-01, B-H-03, B-M-04 |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.model.mjs` | Issues found | B-C-01, B-M-14 |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.routes.mjs` | Issues found | B-C-02 |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.service.mjs` | Issues found | B-C-01, B-C-02, B-C-03, B-M-03, B-M-14 |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.test.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/v1/Auth.validator.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Auth/v1/index.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/EMERGENCY_FEATURES.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/Emergency.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/Emergency.controller.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/Emergency.model.mjs` | Issues found | B-M-01, B-M-17 |
+| `LifeLine-Backend/src/api/Emergency/Emergency.routes.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/Emergency.service.mjs` | Issues found | B-C-07, B-M-01, B-M-02, B-M-10, B-M-17 |
+| `LifeLine-Backend/src/api/Emergency/Emergency.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/Message.model.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Emergency/index.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/HelpRequest/v1/HelperRequest.Controller.mjs` | Issues found | B-L-04 |
+| `LifeLine-Backend/src/api/HelpRequest/v1/HelperRequest.constant.mjs` | Issues found | B-L-04 |
+| `LifeLine-Backend/src/api/HelpRequest/v1/HelperRequest.service.mjs` | Issues found | B-L-04 |
+| `LifeLine-Backend/src/api/HelpRequest/v1/HelperService.mjs` | Issues found | B-L-04 |
+| `LifeLine-Backend/src/api/Helper/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Helper/Helper.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Helper/Helper.controller.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Helper/Helper.model.mjs` | Issues found | B-L-01 |
+| `LifeLine-Backend/src/api/Helper/Helper.routes.mjs` | Issues found | B-C-04, B-H-10 |
+| `LifeLine-Backend/src/api/Helper/Helper.service.mjs` | Issues found | B-L-05 |
+| `LifeLine-Backend/src/api/Helper/Helper.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Helper/HelperPayment.model.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Helper/HelperPayment.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Location/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Location/Location.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Location/Location.controller.mjs` | Issues found | B-H-05, B-M-05 |
+| `LifeLine-Backend/src/api/Location/Location.model.mjs` | Issues found | B-M-09 |
+| `LifeLine-Backend/src/api/Location/Location.routes.mjs` | Issues found | B-H-05, B-H-10 |
+| `LifeLine-Backend/src/api/Location/Location.service.mjs` | Issues found | B-M-05, B-M-09 |
+| `LifeLine-Backend/src/api/Location/Location.utils.mjs` | Issues found | B-M-07 |
+| `LifeLine-Backend/src/api/Medical/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Medical/MEDICAL_FEATURES.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Medical/Medical.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Medical/Medical.controller.mjs` | Issues found | B-H-06, B-M-18 |
+| `LifeLine-Backend/src/api/Medical/Medical.routes.mjs` | Issues found | B-H-06 |
+| `LifeLine-Backend/src/api/Medical/Medical.service.mjs` | Issues found | B-H-06, B-M-18, B-M-19 |
+| `LifeLine-Backend/src/api/Medical/Medical.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Medical/v1/Medical.Schema.mjs` | Issues found | B-M-19 |
+| `LifeLine-Backend/src/api/NGO/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/NGO/NGO.controller.mjs` | Issues found | B-H-09 |
+| `LifeLine-Backend/src/api/NGO/NGO.model.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/NGO/NGO.routes.mjs` | Issues found | B-H-09, B-M-20 |
+| `LifeLine-Backend/src/api/NGO/NGOPayment.model.mjs` | Issues found | B-H-09 |
+| `LifeLine-Backend/src/api/NGO/NGOPayment.utils.mjs` | Issues found | B-H-09 |
+| `LifeLine-Backend/src/api/Notifications/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/Notifications/v1/Notification.controller.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Notifications/v1/Notification.model.mjs` | Issues found | B-M-06 |
+| `LifeLine-Backend/src/api/Notifications/v1/Notification.routes.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Payment/Payment.controller.mjs` | Issues found | B-H-04, B-M-13 |
+| `LifeLine-Backend/src/api/Payment/Payment.model.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/Payment/Payment.routes.mjs` | Issues found | B-H-04 |
+| `LifeLine-Backend/src/api/Payment/Payment.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/User/API.md` | No issues found | - |
+| `LifeLine-Backend/src/api/User/User.constants.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/User/User.controller.mjs` | Issues found | B-C-04 |
+| `LifeLine-Backend/src/api/User/User.routes.mjs` | Issues found | B-C-04, B-H-10 |
+| `LifeLine-Backend/src/api/User/User.service.mjs` | Issues found | B-C-06, B-M-05 |
+| `LifeLine-Backend/src/api/User/User.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/api/User/v1/User.Schema.mjs` | Issues found | B-C-06, B-L-01 |
+| `LifeLine-Backend/src/config/mongo.config.mjs` | Issues found | B-L-03 |
+| `LifeLine-Backend/src/config/socket.config.mjs` | Issues found | B-H-01, B-M-08 |
+| `LifeLine-Backend/src/script/cleanupOrphanLocations.mjs` | No issues found | - |
+| `LifeLine-Backend/src/server.mjs` | Issues found | B-H-01, B-H-08, B-L-02 |
+| `LifeLine-Backend/src/socket/SOCKET_API.md` | No issues found | - |
+| `LifeLine-Backend/src/socket/handlers/emergency.handler.mjs` | Issues found | B-C-05, B-C-07, B-H-07, B-M-06 |
+| `LifeLine-Backend/src/socket/handlers/location.handler.mjs` | Issues found | B-C-05 |
+| `LifeLine-Backend/src/socket/handlers/notification.handler.mjs` | Issues found | B-M-16 |
+| `LifeLine-Backend/src/socket/handlers/triage.handler.mjs` | Issues found | B-C-05 |
+| `LifeLine-Backend/src/socket/index.mjs` | Issues found | B-C-05 |
+| `LifeLine-Backend/src/uploads/profile-pictures/Screenshot_from_2024-10-14_12-07-59-1770918376953-667311719.png` | Binary asset (not inspected) | - |
+| `LifeLine-Backend/src/uploads/profile-pictures/Screenshot_from_2024-10-14_12-07-59-1770918502845-35124623.png` | Binary asset (not inspected) | - |
+| `LifeLine-Backend/src/uploads/profile-pictures/feebfa2d-e8e7-42e8-a624-b3fa5915f48c-1772334762120-49172070.jpeg` | Binary asset (not inspected) | - |
+| `LifeLine-Backend/src/utils/cloudinary.utils.mjs` | No issues found | - |
+| `LifeLine-Backend/src/utils/multer.utils.mjs` | Issues found | B-M-15 |
+| `LifeLine-Backend/test/api.test.js` | No issues found | - |
+| `LifeLine-Backend/test/complete_api.test.js` | No issues found | - |
+| `LifeLine-Backend/test/integration.test.js` | No issues found | - |
diff --git a/docs/risk-assessment-doc-mismatches.md b/docs/risk-assessment-doc-mismatches.md
new file mode 100644
index 0000000..59e010d
--- /dev/null
+++ b/docs/risk-assessment-doc-mismatches.md
@@ -0,0 +1,48 @@
+# Doc / Plan Mismatch Review (LifeLine)
+
+Date: 2026-03-10
+Scope: `docs`, `LifeLine-Backend/docs`
+Method: Static comparison of doc claims vs. codebase state.
+
+## Mismatches
+
+| ID | Severity | Location | Why / How It Breaks | Recommendation |
+|---|---|---|---|---|
+| D-M-01 | Medium | `LifeLine-Backend/docs/api-mismatch-report.md` | This report claims notifications routes are not registered and multiple API paths are mismatched, but current backend and frontend code have already been aligned. The doc is stale and can mislead future work. | Update or remove the doc, or regenerate against current code. |
+
+## Per-File Appendix
+
+| File | Review Status | Issue IDs / Notes |
+|---|---|---|
+| `LifeLine-Backend/docs/01-System-Overview.md` | No issues found | - |
+| `LifeLine-Backend/docs/02-Architecture-Design.md` | No issues found | - |
+| `LifeLine-Backend/docs/03-Features-and-Roadmap.md` | No issues found | - |
+| `LifeLine-Backend/docs/04-Business-Logic-and-Rules.md` | No issues found | - |
+| `LifeLine-Backend/docs/05-Getting-Started.md` | No issues found | - |
+| `LifeLine-Backend/docs/06-Development-Workflow.md` | No issues found | - |
+| `LifeLine-Backend/docs/07-Testing-Strategy.md` | No issues found | - |
+| `LifeLine-Backend/docs/08-Deployment-and-Ops.md` | No issues found | - |
+| `LifeLine-Backend/docs/09-API-Reference.md` | No issues found | - |
+| `LifeLine-Backend/docs/10-Database-Schema.md` | No issues found | - |
+| `LifeLine-Backend/docs/11-Socket-Protocol.md` | No issues found | - |
+| `LifeLine-Backend/docs/12-AI-System-Spec.md` | No issues found | - |
+| `LifeLine-Backend/docs/13-API-Examples.md` | No issues found | - |
+| `LifeLine-Backend/docs/14-Local-Setup.md` | No issues found | - |
+| `LifeLine-Backend/docs/15-AI-Triage-System.md` | No issues found | - |
+| `LifeLine-Backend/docs/16-Backend-Features-Guide.md` | No issues found | - |
+| `LifeLine-Backend/docs/17-Postman-Testing-Flow.md` | No issues found | - |
+| `LifeLine-Backend/docs/18-Public-Access-Guide.md` | No issues found | - |
+| `LifeLine-Backend/docs/20-End-to-End-Workflows.md` | No issues found | - |
+| `LifeLine-Backend/docs/21-SOS-Upgrade-Status-and-Plan.md` | No issues found | - |
+| `LifeLine-Backend/docs/22-Postman-Implemented-Endpoints.md` | No issues found | - |
+| `LifeLine-Backend/docs/api-mismatch-report.md` | Issues found | D-M-01 |
+| `LifeLine-Backend/docs/future-features-design.md` | No issues found | - |
+| `LifeLine-Backend/docs/future-implementation.md` | No issues found | - |
+| `LifeLine-Backend/docs/updated-app-workflow.md` | No issues found | - |
+| `LifeLine-Backend/docs/user-helperconflict.md` | No issues found | - |
+| `docs/ai-triage-sos-hld-lld.md` | No issues found | - |
+| `docs/codebase-risk-assessment.md` | No issues found | - |
+| `docs/future-implementation-summary.md` | No issues found | - |
+| `docs/sos-upgrade-hld-lld.md` | No issues found | - |
+| `docs/tests/sos-first-triage-postman-testing.md` | No issues found | - |
+| `docs/tests/sos-upgrade-postman-testing.md` | No issues found | - |
diff --git a/docs/risk-assessment-frontend.md b/docs/risk-assessment-frontend.md
new file mode 100644
index 0000000..fe40773
--- /dev/null
+++ b/docs/risk-assessment-frontend.md
@@ -0,0 +1,182 @@
+# Frontend Risk Assessment (LifeLine)
+
+Date: 2026-03-10
+Scope: `Lifeline-Frontend`
+Method: Static review of client logic, storage, and API usage. No runtime tests executed.
+
+## Severity Key
+- Critical: Likely to cause security breach, data loss, or core feature failure.
+- High: Breaks important flows or introduces significant security/availability risk.
+- Medium: Breaks edge cases or causes degraded behavior under load.
+- Low: Quality, maintainability, or future risk with limited immediate impact.
+
+## High Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| F-H-01 | High | `src/features/auth/authSlice.ts` | Frontend treats `check-email` response as authenticated session if tokens are returned, enabling login by email only. | Email check flow. | Only set auth state after explicit login/verification. |
+| F-H-02 | High | `app/Helper/Notifications.tsx` | Calls `/api/notifications/v1/user/:userId` which is not implemented; notifications UI always fails. | Opening Notifications screen. | Update endpoint to `/api/notifications/v1` list route. |
+| F-H-03 | High | `src/ai/sarvam-tts.ts`, `src/ai/sarvam-stt.ts` | Uses non-public env var for API key in client; requests fail or leak secrets. | Any TTS/STT call. | Move calls server-side or use `EXPO_PUBLIC_` with proxy. |
+
+## Medium Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| F-M-01 | Medium | `src/features/auth/authSlice.ts`, `src/features/auth/authSession.utils.ts` | Tokens stored in AsyncStorage (plaintext), vulnerable on rooted devices. | Device compromise. | Use SecureStore/Keychain and rotate tokens. |
+| F-M-02 | Medium | `src/shared/tasks/location.task.ts`, `src/shared/hooks/useBackgroundLocation.ts` | Background tracking relies on AsyncStorage keys; missing/stale keys silently drop updates. | Fresh install or logout/login cycles. | Validate keys and rehydrate from auth state. |
+| F-M-03 | Medium | `src/core/App.tsx`, `src/core/Providers.tsx`, `src/core/AppErrorBoundary.tsx` | Error boundary exists but is not wired in; runtime errors crash UI. | Unhandled exception. | Wrap app tree with `AppErrorBoundary`. |
+| F-M-04 | Medium | `src/shared/services/speech.service.ts` | Speech-to-text is silently disabled if native module is missing; no UI feedback. | Expo Go or missing native module. | Provide user-visible fallback/notice. |
+
+## Low Findings
+
+| ID | Severity | Location | Why / How It Breaks | Trigger / Edge Case | Recommendation |
+|---|---|---|---|---|---|
+| F-L-01 | Low | `src/features/User/Section/PrivacySection.tsx.tsx` | Double extension suggests misnamed component; tooling/import errors possible. | Build or refactor. | Rename to `.tsx` and update imports. |
+| F-L-02 | Low | `src/core/Navigation.tsx` | Stub component returns null; may be unused or incomplete. | Future navigation integration. | Remove or implement. |
+| F-L-03 | Low | `src/core/App.tsx` | Placeholder app shell may not reflect actual routing entry; can confuse maintenance. | New developer onboarding. | Document Expo Router entrypoint or remove placeholder. |
+
+## Per-File Appendix
+
+| File | Review Status | Issue IDs / Notes |
+|---|---|---|
+| `Lifeline-Frontend/Dockerfile` | No issues found | - |
+| `Lifeline-Frontend/README.md` | No issues found | - |
+| `Lifeline-Frontend/app.json` | No issues found | - |
+| `Lifeline-Frontend/app/(NGO)/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(global)/Map.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(global)/MedicalProfile/[medical_Id].tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(global)/SOSActiveAIScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/ForgotPassword.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/ForgotPasswordOtp.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/Home.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/Login.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/SignUp.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/(main)/index.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Admin/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/Case.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/CaseDetails.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/Dashboard.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/Earnings.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/EmergencyDetaill.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/Notifications.tsx` | Issues found | F-H-02 |
+| `Lifeline-Frontend/app/Helper/SOSProfile.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/Helper/publicProfile[id].tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Dashboard.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Helper/HelperRequest.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Helper/[helperId].tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Helper/[ngoId].tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/IncomeUserSOS.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Nearby.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Profile/AccountDetails.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Profile/History.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Profile/Profile.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Profile/SavedAddress.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/Profile/SavedAddressScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/User/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/_layout.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/index.tsx` | No issues found | - |
+| `Lifeline-Frontend/app/not-found.tsx` | No issues found | - |
+| `Lifeline-Frontend/assets/icons/icon.png` | Binary asset (not inspected) | - |
+| `Lifeline-Frontend/assets/images/phone.png` | Binary asset (not inspected) | - |
+| `Lifeline-Frontend/babel.config.js` | No issues found | - |
+| `Lifeline-Frontend/eslint.config.js` | No issues found | - |
+| `Lifeline-Frontend/global.css` | No issues found | - |
+| `Lifeline-Frontend/metro.config.js` | No issues found | - |
+| `Lifeline-Frontend/nativewind-env.d.ts` | No issues found | - |
+| `Lifeline-Frontend/package.json` | No issues found | - |
+| `Lifeline-Frontend/plugins/withPowerButtonSOS.js` | No issues found | - |
+| `Lifeline-Frontend/pnpm-lock.yaml` | No issues found | - |
+| `Lifeline-Frontend/src/ai/sarvam-stt.ts` | Issues found | F-H-03 |
+| `Lifeline-Frontend/src/ai/sarvam-tts.ts` | Issues found | F-H-03 |
+| `Lifeline-Frontend/src/config/api.ts` | No issues found | - |
+| `Lifeline-Frontend/src/config/constants.ts` | No issues found | - |
+| `Lifeline-Frontend/src/config/env.ts` | No issues found | - |
+| `Lifeline-Frontend/src/config/permissions.ts` | No issues found | - |
+| `Lifeline-Frontend/src/config/socket.ts` | No issues found | - |
+| `Lifeline-Frontend/src/core/App.tsx` | Issues found | F-M-03, F-L-03 |
+| `Lifeline-Frontend/src/core/AppErrorBoundary.tsx` | Issues found | F-M-03 |
+| `Lifeline-Frontend/src/core/Navigation.tsx` | Issues found | F-L-02 |
+| `Lifeline-Frontend/src/core/Providers.tsx` | Issues found | F-M-03 |
+| `Lifeline-Frontend/src/core/store.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/CaseFooter.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/CaseHeader.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/PatientCard.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/SOSCard.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/ServiceNotes.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/TimelineItem.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Case/Components/TimelineSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/ActivityItem.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/ActivityStat.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/DashboardHeader.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/MetricCard.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Dashbard/v1/Components/StatusToggle.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Earnings/Components/v1/EarningsHeade.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Earnings/Components/v1/EarningsInfoBanner.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Earnings/Components/v1/EarningsStatCard.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Earnings/Components/v1/EarningsSummaryCard.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/Earnings/Components/v1/TransactionItem.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/Helper/helperSlice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/SOS/SOSRuntimeBootstrapper.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/SOS/sos.orchestrator.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/SOS/sos.slice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/Template/v1/userTemplate.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Component/FooterCTASection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Component/UserNav.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/CommunityPoweredSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/CoreFeaturesSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/HeroSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/PrivacySection.tsx.tsx` | Issues found | F-L-01 |
+| `Lifeline-Frontend/src/features/User/Section/RealImpactSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/VerifiedHelpersSection.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/User/Section/WhyLifeLineSec.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/User/Components/AuthUserNav.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/User/Pages/AccountDetails.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/authSession.utils.ts` | Issues found | F-M-01 |
+| `Lifeline-Frontend/src/features/auth/authSlice.ts` | Issues found | F-H-01, F-M-01 |
+| `Lifeline-Frontend/src/features/auth/locationSlice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/medicalSlice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/AccountReadyScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/EmergencyContacts.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/HelperAccountReadyScreenHellper.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/MedicalInfoScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/SecureLocationScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/UniversalMap.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/UserInfo.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/VerifySkillsScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/screens/WelcomeScreen.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/types.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/userSucess.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/validation/index.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/validation/medicalInfoSchema.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/auth/validation/userInfoSchema.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/emergencySlice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/hooks/index.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/hooks/useEmergency.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/index.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/services/triageApi.service.ts` | No issues found | - |
+| `Lifeline-Frontend/src/features/emergency/socketSlice.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/hooks/index.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/hooks/useBackgroundLocation.ts` | Issues found | F-M-02 |
+| `Lifeline-Frontend/src/shared/hooks/useSocket.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/hooks/useSpeech.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/services/index.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/services/socket.service.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/services/speech.service.ts` | Issues found | F-M-04 |
+| `Lifeline-Frontend/src/shared/store/middleware/socketMiddleware.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/tasks/location.task.ts` | Issues found | F-M-02 |
+| `Lifeline-Frontend/src/shared/utils/error.utils.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/utils/locationStabilizer.ts` | No issues found | - |
+| `Lifeline-Frontend/src/shared/utils/notification.utils.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/ThemeContext.tsx` | No issues found | - |
+| `Lifeline-Frontend/src/theme/colors.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/darkTheme.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/lightTheme.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/spacing.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/types.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/typography.ts` | No issues found | - |
+| `Lifeline-Frontend/src/theme/useTheme.ts` | No issues found | - |
+| `Lifeline-Frontend/src/utils/filePicker.utils.ts` | No issues found | - |
+| `Lifeline-Frontend/tailwind.config.js` | No issues found | - |
+| `Lifeline-Frontend/tsconfig.json` | No issues found | - |
diff --git a/docs/sos-upgrade-hld-lld.md b/docs/sos-upgrade-hld-lld.md
new file mode 100644
index 0000000..305acd0
--- /dev/null
+++ b/docs/sos-upgrade-hld-lld.md
@@ -0,0 +1,158 @@
+# SOS Upgrade HLD & LLD
+
+This document defines the high-level design (HLD) and low-level design (LLD) for the SOS upgrade roadmap, including payment approval, OTP verification, helper stats, and SOS profile access.
+
+## HLD
+
+### Goals
+- Support paid/free SOS flow with approval and OTP verification.
+- Provide helper-facing SOS profile view with medical snapshot.
+- Track helper earnings and performance metrics for stats.
+- Keep compatibility with existing emergency flow and triage triggers.
+
+### Scope
+- Emergency payment approval and OTP verification endpoints.
+- Payment persistence and release logic.
+- SOS profile data aggregation.
+- Helper stats API enhancement.
+- Notification and socket event integration for SOS flow.
+
+### Non-Goals
+- Replacing existing emergency create/resolve APIs.
+- Changing triage decision logic beyond triggering SOS.
+- Full analytics dashboard implementation.
+
+### System Components
+- **Frontend**: SOS UI, helper acceptance screens, OTP entry UI, stats screens.
+- **Backend API**: Emergency, Helper, Payment, Notification, Auth modules.
+- **Database**: Emergency, Helper, Payment, User/Medical collections.
+- **Realtime**: Socket events for SOS lifecycle and payment updates.
+- **Notification**: Push/SMS/email for approval/OTP and status updates.
+
+### Data Flow Overview
+1. User triggers SOS (manual or AI decision).
+2. Emergency created; helpers assigned.
+3. Helper accepts with service type and amount (paid/free).
+4. User approves payment → OTP sent to user phone.
+5. User verifies OTP → payment marked verified → helper earnings updated.
+6. Helper can view SOS profile for assigned emergencies.
+7. Helper stats endpoint returns earnings and performance.
+
+### Security & Access
+- Auth middleware on all endpoints.
+- SOS profile visible only to assigned helpers.
+- OTP verification tied to emergency owner.
+- Payment operations restricted to emergency owner and assigned helper.
+
+### Dependencies
+- Fast2SMS for OTP.
+- Socket.IO for realtime.
+- MongoDB for persistence.
+
+### Risks & Mitigations
+- **OTP delivery failures**: fallback to resend; expose otpSent flag.
+- **Payment mismatches**: enforce server-side validation of amounts.
+- **Unauthorized access**: strict checks on emergency ownership and assignment.
+
+---
+
+## LLD
+
+### Data Models
+
+#### Emergency (additional fields)
+- payment.status: enum [none, approved, verified]
+- payment.otp
+- payment.otpExpiresAt
+- payment.approvedAt
+- payment.approvedBy
+- payment.verifiedAt
+- payment.verifiedBy
+- requiredHelpers
+- serviceType
+- acceptedHelpers[]
+
+#### Payment (new collection)
+- emergencyId
+- helperId
+- userId
+- amount
+- status: enum [pending, approved, verified, released, failed]
+- method: enum [cash, upi, card]
+- createdAt, updatedAt
+
+#### Helper (extensions)
+- totalEarnings
+- pendingAmount
+- casesSolved
+- activeCase
+
+### APIs
+
+#### Emergency
+- POST /api/emergency/:id/approve
+  - Body: {}
+  - Behavior: generate OTP, store on emergency.payment, send SMS
+  - Response: { otpSent, emergencyId }
+
+- POST /api/emergency/:id/verify-otp
+  - Body: { otp }
+  - Behavior: validate OTP and expiry; set payment.status=verified
+  - Response: { paymentStatus }
+
+- GET /api/emergency/:id/profile
+  - Behavior: assigned helper only; returns user + medical summary
+  - Response: { userProfile, medicalSnapshot, emergencySummary }
+
+#### Helper
+- GET /api/helpers/stats/:helperId
+  - Behavior: return earnings + performance
+  - Response: { earnings, performance, recentActivity }
+
+#### Payment
+- POST /api/payments
+  - Body: { emergencyId, helperId, userId, amount, method }
+  - Behavior: create payment record on paid accept
+
+- PATCH /api/payments/:id/release
+  - Behavior: mark released after OTP verification
+
+### Service Logic
+
+#### EmergencyService.approveEmergencyPayment
+- Validate emergency exists and user owns it.
+- Generate OTP and expiry.
+- Persist on emergency.payment.
+- Send OTP to user phone.
+
+#### EmergencyService.verifyEmergencyOtp
+- Validate OTP and expiry.
+- Update emergency.payment.status to verified.
+- Trigger payment release workflow.
+
+#### HelperService.getDashboardMetrics
+- Extend to compute totalEarnings, pendingAmount.
+- Derive from Payment collection (paid) + resolved emergencies (free).
+
+#### SOS Profile
+- Fetch user, medical, and emergency records.
+- Ensure helper is assigned in emergency.assignedHelpers.
+
+### Socket Events
+- emergency:payment_approved
+- emergency:payment_verified
+- emergency:profile_ready
+- helper:stats_updated
+
+### Error Handling
+- 400 for validation errors.
+- 401 for missing auth.
+- 403 for unauthorized access.
+- 404 for missing resources.
+
+### Testing Checklist
+- SOS paid accept → approve → OTP verify → release.
+- SOS free accept flow (no OTP).
+- Helper stats returns accurate totals.
+- SOS profile accessible only by assigned helpers.
+- Socket events emitted and received.
diff --git a/docs/tests/sos-first-triage-postman-testing.md b/docs/tests/sos-first-triage-postman-testing.md
new file mode 100644
index 0000000..d1f9ea9
--- /dev/null
+++ b/docs/tests/sos-first-triage-postman-testing.md
@@ -0,0 +1,226 @@
+# SOS-First + AI Triage Postman Testing Guide
+
+This guide validates the SOS-first flow where SOS is created immediately and AI triage enriches the existing emergency.
+
+## Base Setup
+
+**Base URL**
+- `{{base_url}}` = `http://localhost:5000`
+
+**Auth**
+- Use `Authorization: Bearer {{access_token}}` for all protected endpoints.
+- Token comes from login (`/api/auth/v1/login`).
+
+**Environment Variables**
+- `base_url`
+- `access_token`
+- `emergency_id`
+- `triage_session_id`
+
+---
+
+## 1) Login (Get Access Token)
+
+**POST** `{{base_url}}/api/auth/v1/login`
+
+**Headers**
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "email": "user@example.com",
+  "password": "your_password"
+}
+```
+
+**Expected Response**
+- `success: true`
+- `data.accessToken` (store as `{{access_token}}`)
+
+---
+
+## 2) Create SOS Immediately (SOS-First)
+
+**POST** `{{base_url}}/api/emergency/sos`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "title": "Medical SOS",
+  "message": "User initiated SOS",
+  "type": "medical",
+  "priority": "critical",
+  "latitude": 28.6139,
+  "longitude": 77.2090,
+  "address": "Connaught Place, New Delhi",
+  "accuracy": 15,
+  "medicalInfo": {},
+  "settings": {
+    "autoAssignHelpers": true,
+    "notifyGuardians": true,
+    "maxHelpers": 3
+  }
+}
+```
+
+**Expected Response**
+- `success: true`
+- `data.emergency._id` (store as `{{emergency_id}}`)
+
+---
+
+## 3) Start AI Triage Session (Bind to Existing SOS)
+
+**POST** `{{base_url}}/api/triage/start`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "emergencyId": "{{emergency_id}}",
+  "location": {
+    "latitude": 28.6139,
+    "longitude": 77.2090
+  },
+  "language": "en",
+  "emergencyType": "medical"
+}
+```
+
+**Expected Response**
+- `success: true`
+- `sessionId` (store as `{{triage_session_id}}`)
+- `greeting`
+
+---
+
+## 4) Send Triage Message (Need More Info)
+
+**POST** `{{base_url}}/api/triage/message`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "sessionId": "{{triage_session_id}}",
+  "message": "I feel dizzy and have chest pain"
+}
+```
+
+**Expected Response (Typical)**
+- `decision: "need_more_info"`
+- `question: "..."`
+
+---
+
+## 5) Send Triage Message (Create Emergency + Enrich Existing SOS)
+
+**POST** `{{base_url}}/api/triage/message`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "sessionId": "{{triage_session_id}}",
+  "message": "Severe chest pain, difficulty breathing, collapsed"
+}
+```
+
+**Expected Response**
+- `decision: "create_emergency"`
+- `emergencyCreated: true`
+- `emergencyId: "{{emergency_id}}"`
+- `emergencyData` contains updated `title/description/type/priority`
+
+---
+
+## 6) Verify SOS Updated by AI
+
+**GET** `{{base_url}}/api/emergency/{{emergency_id}}`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+
+**Expected Response**
+- `success: true`
+- `data.title/description/type/priority` reflect AI-enriched values
+
+---
+
+## 7) Optional: Cancel Triage Session
+
+**POST** `{{base_url}}/api/triage/cancel`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "sessionId": "{{triage_session_id}}"
+}
+```
+
+**Expected Response**
+- `success: true`
+- `message: "Session cancelled"`
+
+---
+
+## 8) Optional: Resolve Emergency
+
+**PUT** `{{base_url}}/api/emergency/{{emergency_id}}/resolve`
+
+**Headers**
+- `Authorization: Bearer {{access_token}}`
+- `Content-Type: application/json`
+
+**Body (raw JSON)**
+```json
+{
+  "resolutionType": "user_resolved",
+  "notes": "User confirmed situation is stable now"
+}
+```
+
+**Expected Response**
+- `success: true`
+- `data.status: "resolved"`
+
+---
+
+## Edge Case Tests
+
+### A) Missing Emergency ID on SOS-First Start
+Start triage without `emergencyId` and verify:
+- Session starts
+- If AI decision is `create_emergency`, backend will create a new SOS
+
+### B) Unauthorized Emergency ID
+Use an `emergencyId` not owned by the logged-in user:
+- Expected: 403 or 500 with `UNAUTHORIZED` in error message
+
+### C) Invalid Coordinates for SOS
+Trigger SOS with invalid latitude/longitude:
+- Expected: 400 with validation error message
+
+---
+
+## Notes
+- `POST /api/emergency/sos` requires `latitude`, `longitude`, and `address`.
+- Triage uses AI; responses may vary based on prompt and conversation context.
diff --git a/docs/tests/sos-upgrade-postman-testing.md b/docs/tests/sos-upgrade-postman-testing.md
new file mode 100644
index 0000000..e598028
--- /dev/null
+++ b/docs/tests/sos-upgrade-postman-testing.md
@@ -0,0 +1,211 @@
+# SOS Upgrade Testing Guide (Postman + API)
+
+This document provides a step-by-step guide to test the SOS upgrade flows using Postman. It covers the paid/free accept flow, OTP approval/verification, helper stats, and SOS profile access.
+
+## 1) Prerequisites
+
+### Environment
+- Backend running on: `http://localhost:5000`
+- Postman collection with an environment variable:
+  - `baseUrl = http://localhost:5000`
+  - `userToken` = JWT for a user
+  - `helperToken` = JWT for a helper
+
+### Required Test Data
+- A user account with a completed profile
+- A helper account marked as available
+- Helper and user must be near each other (location set)
+- A valid Emergency ID created via SOS
+
+## 2) Auth Setup (Once)
+
+### Login User
+**POST** `{{baseUrl}}/api/auth/v1/login`
+```json
+{
+  "email": "user@example.com",
+  "password": "password123"
+}
+```
+Save the JWT as `userToken`.
+
+### Login Helper
+**POST** `{{baseUrl}}/api/auth/v1/login`
+```json
+{
+  "email": "helper@example.com",
+  "password": "password123"
+}
+```
+Save the JWT as `helperToken`.
+
+## 3) Trigger SOS (Create Emergency)
+
+### Trigger SOS (User API)
+**POST** `{{baseUrl}}/api/emergency/sos`
+Headers: `Authorization: Bearer {{userToken}}`
+```json
+{
+  "type": "medical",
+  "title": "Unconscious patient",
+  "description": "User fainted and needs immediate help",
+  "priority": "critical",
+  "location": {
+    "coordinates": [77.5946, 12.9716],
+    "address": "MG Road, Bengaluru"
+  }
+}
+```
+Copy `data._id` as `emergencyId`.
+
+## 4) Helper Accept Flow (Paid/Free)
+
+### Accept Free Case (Helper API)
+**PUT** `{{baseUrl}}/api/emergency/{{emergencyId}}/accept`
+Headers: `Authorization: Bearer {{helperToken}}`
+```json
+{
+  "serviceType": "basic_support",
+  "amount": 0,
+  "method": "cash"
+}
+```
+
+### Accept Paid Case (Helper API)
+**PUT** `{{baseUrl}}/api/emergency/{{emergencyId}}/accept`
+Headers: `Authorization: Bearer {{helperToken}}`
+```json
+{
+  "serviceType": "paramedic",
+  "amount": 1500,
+  "method": "upi"
+}
+```
+
+## 5) Complete SOS (Resolve)
+
+### Resolve Emergency (User API)
+**PUT** `{{baseUrl}}/api/emergency/{{emergencyId}}/resolve`
+Headers: `Authorization: Bearer {{userToken}}`
+```json
+{
+  "resolutionType": "completed",
+  "notes": "Helper provided first aid",
+  "rating": 5,
+  "feedback": "Quick response"
+}
+```
+
+## 6) Payment Approval (After Resolution)
+
+### Approve Payment (Send OTP) (User API)
+**POST** `{{baseUrl}}/api/emergency/{{emergencyId}}/approve`
+Headers: `Authorization: Bearer {{userToken}}`
+
+Expected:
+```json
+{
+  "success": true,
+  "data": {
+    "emergencyId": "...",
+    "otpSent": true
+  }
+}
+```
+
+## 7) Verify OTP (Release Payment)
+
+### Verify OTP (User API)
+**POST** `{{baseUrl}}/api/emergency/{{emergencyId}}/verify-otp`
+Headers: `Authorization: Bearer {{userToken}}`
+```json
+{
+  "otp": "123456"
+}
+```
+
+Expected:
+```json
+{
+  "success": true,
+  "data": {
+    "emergencyId": "...",
+    "paymentStatus": "verified"
+  }
+}
+```
+
+## 8) SOS Profile (Helper Access Only)
+
+### Get SOS Profile (Helper API)
+**GET** `{{baseUrl}}/api/emergency/{{emergencyId}}/profile`
+Headers: `Authorization: Bearer {{helperToken}}`
+
+Expected:
+```json
+{
+  "success": true,
+  "data": {
+    "userProfile": {},
+    "medicalSnapshot": {},
+    "emergencySummary": {}
+  }
+}
+```
+
+## 9) Helper Stats
+
+### Get Helper Stats (Helper API)
+**GET** `{{baseUrl}}/api/helpers/v1/stats/{{helperAuthId}}`
+Headers: `Authorization: Bearer {{helperToken}}`
+
+Expected:
+```json
+{
+  "success": true,
+  "data": {
+    "today": {},
+    "earnings": {
+      "total": 1500,
+      "pending": 0
+    },
+    "stats": {
+      "casesSolved": 1,
+      "activeCases": 0
+    }
+  }
+}
+```
+
+## 10) Payment API (Direct Testing)
+
+### Create Payment (User API)
+**POST** `{{baseUrl}}/api/payments`
+Headers: `Authorization: Bearer {{userToken}}`
+```json
+{
+  "emergencyId": "{{emergencyId}}",
+  "helperId": "{{helperAuthId}}",
+  "userId": "{{userAuthId}}",
+  "amount": 1500,
+  "method": "upi",
+  "serviceType": "paramedic"
+}
+```
+
+### Release Payment (User API)
+**PATCH** `{{baseUrl}}/api/payments/{{paymentId}}/release`
+Headers: `Authorization: Bearer {{userToken}}`
+
+## 11) Negative Tests
+
+- Approve payment before resolve → expect `400` with message: `Payment can only be approved after resolution`.
+- Verify OTP before approve → expect `400` with message: `OTP not available for verification`.
+- Non-owner tries approve/verify → expect `403` unauthorized.
+- Helper tries SOS profile for unrelated emergency → expect `403` unauthorized.
+
+## 12) Common Errors
+
+- `Payment not required for this emergency` → amount was 0 or missing on accept.
+- `Payment is not pending approval` → already approved or released.
+- `OTP expired` → OTP lifetime is 5 minutes.
diff --git a/implementation_plan.md b/implementation_plan.md
index a2b80b5..d10b502 100644
--- a/implementation_plan.md
+++ b/implementation_plan.md
@@ -10,13 +10,13 @@
 
 ## STEP 1: Understanding Our Users
 
-### Three Types of People Will Use LifeLine:
+### Three Types of People Will Use LifeLine
 
 1. **Normal User** – Someone who needs help in an emergency
 2. **Helper** – Doctor, nurse, or trained volunteer who can help others
 3. **Admin** – Manages and verifies helpers (we'll build this later)
 
-### Our Main Goals:
+### Our Main Goals
 
 * ✅ Help arrives in **2–5 minutes** (not 30 minutes!)
 * ✅ One simple SOS button (big and red!)
@@ -30,7 +30,7 @@
 
 ## STEP 2: Choose Technology (Frontend)
 
-### What We'll Use:
+### What We'll Use
 
 * **React Native + Expo** → Build app for both iPhone and Android
 * **TypeScript** → Makes code safer and easier to maintain
@@ -60,13 +60,13 @@ src/
 
 ## STEP 4: Theme System (Light & Dark Mode)
 
-### Why Theme Matters:
+### Why Theme Matters
 
 * In emergencies, **colors must be clear**
 * Text must be **easy to read** (even in panic)
 * **Same design everywhere** (consistency)
 
-### What Our Theme Contains:
+### What Our Theme Contains
 
 | Theme Element | Light Mode | Dark Mode |
 | --- | --- | --- |
@@ -76,7 +76,7 @@ src/
 | Success | Green (#00C853) | Green (#00C853) |
 | Warning | Orange (#FF6D00) | Orange (#FF6D00) |
 
-### How It Works:
+### How It Works
 
 * We use **React Context** (`useTheme`)
 * User can switch between light and dark
@@ -88,7 +88,7 @@ src/
 
 ## STEP 5: Ask for Phone Permissions
 
-### Why We Need Each Permission:
+### Why We Need Each Permission
 
 | Permission | Why We Need It | When We Ask |
 | --- | --- | --- |
@@ -98,7 +98,7 @@ src/
 | **Microphone** | Voice guidance (optional) | Only if user wants it |
 | **Motion Sensors** | Detect falls automatically | When enabling fall detection |
 
-### How We Ask (Politely!):
+### How We Ask (Politely!)
 
 * Show a simple screen that says:
   > "We need your location to send help near you. Without this, we can't find helpers."
@@ -111,7 +111,7 @@ src/
 
 ## STEP 6: The SOS Button Flow
 
-### Simple 6-Step Process:
+### Simple 6-Step Process
 
 1. **User opens app** → Sees big red SOS button
 2. **User taps SOS** → Button starts pulsing
@@ -120,7 +120,7 @@ src/
 5. **Send to server** → Emergency request sent
 6. **Emergency Mode** → App changes to emergency screen
 
-### What Emergency Mode Shows:
+### What Emergency Mode Shows
 
 * **"Help is on the way!"** (big text)
 * **Distance to helper** (e.g., "Help 400m away")
@@ -133,7 +133,7 @@ src/
 
 ## STEP 7: Find Nearby Helpers (Like Uber!)
 
-### How It Works Behind the Scenes:
+### How It Works Behind the Scenes
 
 1. **User triggers SOS** → App sends location to server
 2. **Server searches database** → Looks for helpers within 500 meters
@@ -142,7 +142,7 @@ src/
 5. **Alert top 5 helpers** → Send notification to 5 closest
 6. **First to accept wins** → Their profile shows to user
 
-### Database Design (Simple):
+### Database Design (Simple)
 
 ```
 Helpers Collection:
@@ -159,26 +159,28 @@ Helpers Collection:
 
 ## STEP 8: Fake SOS Filter (Avoid Pranks)
 
-### The Problem:
+### The Problem
 
 * Some people might press SOS by accident
 * Some might misuse the system
 
-### Our Solution:
+### Our Solution
 
 **Level 1 – Simple Check:**
+
 * After SOS pressed, app asks: **"Are you safe?"**
 * No response in 10 seconds = **Real emergency** → Send alert
 * User responds "Yes, I'm safe" = **Cancel** → No alert sent
 
 **Level 2 – AI Check (Advanced):**
+
 * Analyze **voice tone** (is the person panicking?)
 * Check **phone motion** (did phone just fall hard?)
 * Look for **keywords** ("Help!", "Emergency!", screaming)
 
 ## STEP 9: Live Guidance (Voice Instructions)
 
-### During Emergency:
+### During Emergency
 
 * **App speaks out loud:**
   * "Stay calm. Help is 2 minutes away."
@@ -193,14 +195,14 @@ Helpers Collection:
 
 ## STEP 10: Server Technology
 
-### What We'll Use:
+### What We'll Use
 
 * **Node.js + Express** → Fast server that handles requests
 * **MongoDB** → Database to store users and emergencies
 * **Socket.io** → Real-time updates (live tracking)
 * **Firebase** → Send notifications to phones
 
-### What Backend Handles:
+### What Backend Handles
 
 * ✅ User login & signup
 * ✅ SOS requests (receive and process)
@@ -209,7 +211,7 @@ Helpers Collection:
 * ✅ Track emergencies (save history)
 * ✅ Verify helpers (check credentials)
 
-### Backend Folder Structure:
+### Backend Folder Structure
 
 ```
 backend/
@@ -226,7 +228,7 @@ backend/
 
 ## STEP 11: What Data We Store
 
-### User Data:
+### User Data
 
 ```
 - Name (e.g., "John Doe")
@@ -237,7 +239,7 @@ backend/
 - Medical ID (Blood type, allergies, conditions)
 ```
 
-### Emergency Data:
+### Emergency Data
 
 ```
 - User ID (who triggered it)
@@ -247,7 +249,7 @@ backend/
 - Helper ID (who responded)
 ```
 
-### Helper Data:
+### Helper Data
 
 ```
 - Credentials (Medical license, certificate)
@@ -263,13 +265,13 @@ backend/
 
 ## STEP 12: Notification System
 
-### Who Gets Notified:
+### Who Gets Notified
 
 1. **Nearby helpers** → "Emergency 400m away! Can you help?"
 2. **User's family** → "John has triggered an SOS at [location]"
 3. **User** → "Help is on the way. Stay calm."
 
-### Tools We Use:
+### Tools We Use
 
 * **Firebase Cloud Messaging** → Send to Android & iPhone
 * **Expo Notifications** → Handle notifications in app
@@ -277,17 +279,17 @@ backend/
 
 ## STEP 13: Notification Priority
 
-### Critical (Red):
+### Critical (Red)
 
 * **SOS alerts to helpers** → Phone rings loudly, vibrates
 * **Emergency updates** → "Helper is 1 minute away"
 
-### Important (Orange):
+### Important (Orange)
 
 * **Helper accepted** → "Dr. Sarah is coming to help you"
 * **Status updates** → "Emergency resolved"
 
-### Normal (Gray):
+### Normal (Gray)
 
 * **Profile updates** → "Complete your Medical ID"
 * **Community** → "5 people helped this week in your area"
@@ -298,13 +300,13 @@ backend/
 
 ## STEP 14: Keep Data Safe
 
-### Basic Security:
+### Basic Security
 
 * **Login tokens** → Expire after 7 days
 * **Data encryption** → All data encrypted in database
 * **HTTPS only** → All communication is secure
 
-### Prevent Misuse:
+### Prevent Misuse
 
 * **Limit SOS triggers** → Max 3 per day (unless verified emergency)
 * **Helper verification** → Must upload credentials
@@ -317,7 +319,7 @@ backend/
 
 ## STEP 15: Blood Connect (Life-Saving!)
 
-### What It Does:
+### What It Does
 
 * If emergency needs **blood donation**
 * System finds helpers with **matching blood type** nearby
@@ -325,22 +327,22 @@ backend/
 
 ## STEP 16: Guardian Live Tracking
 
-### What It Does:
+### What It Does
 
 * When SOS triggered, **family gets a link** via SMS
 * Link opens map showing:
   * Where you are
   * Where helper is
-  * Live updates every 10 seconds
+  * Live updates near every 5 seconds (with filtering to reduce GPS jitter)
 
-### Example:
+### Example
 
 * Mom gets SMS: "John triggered SOS. Track live: lifeline.app/track/abc123"
 * She opens link and sees map with both locations
 
 ## STEP 17: Offline Mode (No Internet? No Problem!)
 
-### What It Does:
+### What It Does
 
 * **Pre-download first aid instructions** (CPR, bleeding, choking)
 * **SMS fallback** → If no internet, send SMS to emergency contacts
@@ -348,13 +350,13 @@ backend/
 
 ## STEP 18: Fall Detection (Auto SOS)
 
-### What It Does:
+### What It Does
 
 * **Phone detects hard fall** (using motion sensors)
 * **App asks: "Are you okay?"**
 * **No response in 30 seconds?** → Auto-trigger SOS
 
-### Great For:
+### Great For
 
 * Elderly people living alone
 * Cyclists & motorcyclists
@@ -362,7 +364,7 @@ backend/
 
 ## STEP 19: Safety Mode (Daily Use)
 
-### What It Does:
+### What It Does
 
 * **"Walking Home Alone" mode:**
   * Share live location with friend
@@ -375,7 +377,7 @@ backend/
 
 ## STEP 20: Community Hero Rewards (Gamification)
 
-### What It Does:
+### What It Does
 
 * Helpers earn **badges** for helping people:
   * 🥉 Bronze: Helped 1 person
@@ -388,7 +390,7 @@ backend/
   * User ratings
   * Number of lives helped
 
-### Why It Works:
+### Why It Works
 
 * People love being recognized
 * Creates positive community culture
@@ -396,7 +398,7 @@ backend/
 
 ## STEP 21: Medical ID (Critical Info)
 
-### What It Does:
+### What It Does
 
 * Store encrypted medical profile:
   * Blood type (O+, A-, etc.)
@@ -409,14 +411,14 @@ backend/
 
 ## STEP 22: Voice Tone Analysis (AI)
 
-### What It Does:
+### What It Does
 
 * When user triggers SOS, app listens to voice
 * **AI detects panic/distress** in voice tone
 * If genuine distress detected → Increase priority
 * If calm voice → Ask "Are you sure this is emergency?"
 
-### Technology:
+### Technology
 
 * Use phone's microphone
 * Simple AI model (doesn't need internet)
@@ -428,20 +430,20 @@ backend/
 
 ## STEP 23: What We Must Test
 
-### Speed Tests:
+### Speed Tests
 
 * ✅ SOS reaches server in less than **2 seconds**
 * ✅ Helpers get notification within **3 seconds**
 * ✅ Location accuracy within **10 meters**
 
-### Reliability Tests:
+### Reliability Tests
 
 * ✅ App works with **slow internet** (3G)
 * ✅ App works with **no internet** (offline mode)
 * ✅ App doesn't crash when **phone battery low**
 * ✅ App works on **old phones** (5 years old)
 
-### Real-World Tests:
+### Real-World Tests
 
 * ✅ Test in crowded areas (many users)
 * ✅ Test in rural areas (few users)
@@ -454,14 +456,14 @@ backend/
 
 ## STEP 24: Who Does What
 
-### Development Team:
+### Development Team
 
 * **2 Frontend Developers** → Build mobile app screens
 * **2 Backend Developers** → Build server & database
 * **1 Designer (UX/UI)** → Make it beautiful & easy
 * **1 QA Tester** → Test everything thoroughly
 
-### Timeline Estimate:
+### Timeline Estimate
 
 * **Month 1-2:** Foundation (login, basic UI, backend setup)
 * **Month 3:** SOS core feature
@@ -475,7 +477,7 @@ backend/
 
 ## STEP 25: How We Know It's Working
 
-### Key Metrics:
+### Key Metrics
 
 * ⏱️ **Response time:** Average time from SOS to helper arrival (Goal: < 5 minutes)
 * 💯 **Success rate:** % of emergencies where help arrived (Goal: > 95%)
@@ -501,46 +503,52 @@ LifeLine must be:
 ## 📋 Implementation Checklist
 
 ### Phase 1 – Foundation (Week 1-2)
+
 - [ ] Set up React Native + Expo project
-- [ ] Set up Node.js + Express backend
-- [ ] Create MongoDB database
-- [ ] Design theme system (colors, fonts)
-- [ ] Create folder structure
+* [ ] Set up Node.js + Express backend
+* [ ] Create MongoDB database
+* [ ] Design theme system (colors, fonts)
+* [ ] Create folder structure
 
 ### Phase 2 – Authentication (Week 3)
+
 - [ ] Build login screen
-- [ ] Build signup screen
-- [ ] Implement JWT tokens
-- [ ] Add phone verification (OTP)
+* [ ] Build signup screen
+* [ ] Implement JWT tokens
+* [ ] Add phone verification (OTP)
 
 ### Phase 3 – Core SOS (Week 4-5)
+
 - [ ] Build SOS button UI
-- [ ] Implement location capture
-- [ ] Create emergency mode screen
-- [ ] Set up Socket.io for real-time
-- [ ] Build helper matching logic
+* [ ] Implement location capture
+* [ ] Create emergency mode screen
+* [ ] Set up Socket.io for real-time
+* [ ] Build helper matching logic
 
 ### Phase 4 – Notifications (Week 6)
+
 - [ ] Integrate Firebase notifications
-- [ ] Create notification templates
-- [ ] Test notification delivery
-- [ ] Add SMS fallback
+* [ ] Create notification templates
+* [ ] Test notification delivery
+* [ ] Add SMS fallback
 
 ### Phase 5 – Hero Features (Week 7-10)
+
 - [ ] Build Medical ID feature
-- [ ] Implement Guardian tracking
-- [ ] Add Blood Connect
-- [ ] Create Safety Mode
-- [ ] Build Community Rewards
-- [ ] Add Fall Detection
-- [ ] Implement Offline Mode
+* [ ] Implement Guardian tracking
+* [ ] Add Blood Connect
+* [ ] Create Safety Mode
+* [ ] Build Community Rewards
+* [ ] Add Fall Detection
+* [ ] Implement Offline Mode
 
 ### Phase 6 – Testing & Launch (Week 11-12)
+
 - [ ] Complete QA testing
-- [ ] Fix all bugs
-- [ ] Optimize performance
-- [ ] Prepare app store listings
-- [ ] Launch beta version
+* [ ] Fix all bugs
+* [ ] Optimize performance
+* [ ] Prepare app store listings
+* [ ] Launch beta version
 
 ---