Updating

app.py

@@ -1,8 +1,18 @@
+"""
+Enhanced Abdullah Bot API - Combining structured journey management with refined persona architecture.
+Improvements from Path of the Awaited integration:
+- Enhanced tone detection with multilingual support (Arabic/Urdu keywords)
+- Structured response parsing (Voice Answer / Middle Section / Follow-up)
+- Better language detection (Urdu script + Roman Urdu)
+- Improved error handling with retry logic
+- Post-processing for citations and references
+- Meta-question handling for self-awareness
+"""
 import os
 import logging
 import re
-from typing import Dict, List, Optional
-from fastapi import FastAPI, HTTPException
+from typing import Dict, List, Optional, Tuple, Any
+from fastapi import FastAPI, HTTPException, BackgroundTasks
 from pydantic import BaseModel
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, pipeline
@@ -10,11 +20,16 @@ from fastapi.responses import HTMLResponse
 from datetime import datetime, timedelta
 import random
 import json
+import requests
 from db_helper import DB
+from langdetect import detect, DetectorFactory
+
+# Ensure consistent language detection
+DetectorFactory.seed = 0
 
 # Logging setup
 logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
-logger = logging.getLogger("personality_bot_api")
+logger = logging.getLogger("enhanced_abdullah_bot_api")
 
 # DB instance
 db = DB()
@@ -48,102 +63,220 @@ for q in BASE_MCQS:
 MCQ_OPTIONS = ["Always", "Often", "Sometimes", "Rarely", "Never"]
 SCORE_MAP = {"Always": 5, "Often": 4, "Sometimes": 3, "Rarely": 2, "Never": 1}
 
-# SYSTEM_PROMPT (fixed em-dashes)
+# ENHANCED TONE DETECTION with multilingual support
+TONE_KEYWORDS = {
+    "sad": ["sad", "depressed", "down", "unhappy", "sorrow", "lonely", "pain", "hurt", "dukhi", 
+            "افسردہ", "غمگین", "پریشان", "udasi", "اداسی", "حزين", "محزون"],
+    "confused": ["confused", "dont know", "what now", "uncertain", "lost", "perplexed", "uljhan", 
+                 "الجھن", "samajh nahi", "سمجھ نہیں", "shak", "شک"],
+    "energetic": ["excited", "hyped", "lets go", "pump", "energetic", "josh", "جوش"],
+    "dive_deep": ["explain in detail", "deep", "dive", "analyze", "break down", "detail", "tafseel", 
+                  "تفصیل", "تفصیلی", "explain step", "تفصیل سے"],
+    "angry": ["angry", "mad", "furious", "pissed", "upset", "ghussa", "غصہ"],
+    "curious": ["wonder", "curious", "why is", "what is", "how come", "kyun", "کیوں"],
+    "anxious": ["anxious", "stressed", "worried", "nervous", "paranoid", "fikar", "فکر", "پریشان"],
+    "grateful": ["thankful", "grateful", "appreciate", "shukriya", "شکریہ", "alhamdulillah", "الحمدللہ"],
+    "urgent": ["urgent", "now", "immediately", "asap", "right now", "jaldi", "فوراً"],
+    "reflective": ["purpose", "meaning", "reflect", "ponder", "soch", "سوچ"],
+    "humorous": ["funny", "joke", "hilarious", "make me laugh", "mazahia", "مزاحیہ"],
+    "skeptical": ["doubt", "skeptical", "not sure", "prove it", "really?", "shak", "شک"],
+    "neutral": []
+}
+
+# ENHANCED TONE INSTRUCTIONS with Islamic context
+TONE_INSTRUCTION_MAP = {
+    "sad": "Tone: gentle, uplifting, encouraging with Islamic comfort. Use hopeful language with Quranic reassurance. Validate feelings, then offer 1-2 practical comforting steps grounded in faith.",
+    "confused": "Tone: supportive and clarifying with patience. Break explanations into numbered steps. Use simple Urdu/Arabic terms where appropriate. Ask one concise clarifying question when necessary.",
+    "energetic": "Tone: high-energy and motivating with Islamic encouragement (e.g., 'جوش برقرار رکھیں'). Offer 2-3 immediate action prompts aligned with purpose.",
+    "dive_deep": "Tone: calm, thorough, and structured. Use sections (خلاصہ/Summary, تفصیل/Details, Example). Provide numbered sections with Islamic references where relevant.",
+    "angry": "Tone: calm and de-escalating. Use short sentences (e.g., 'غصہ کم کریں'). Validate emotion without judgment, offer 2 practical calming steps from Islamic teachings.",
+    "curious": "Tone: engaging and instructive. Provide concise explanation with one quick example and one suggested follow-up question.",
+    "anxious": "Tone: soothing and reassuring. Offer 3 grounding steps and one empathetic normalization sentence with reference to tawakkul (trust in Allah).",
+    "grateful": "Tone: warm and reflective. Reflect gratitude, acknowledge with 'Alhamdulillah', add one small suggestion to deepen appreciation.",
+    "urgent": "Tone: direct and actionable. Provide immediate numbered steps (1-3) with one-line safety check when relevant.",
+    "reflective": "Tone: introspective and contemplative. Offer a short metaphor or Quranic image, end with one practical takeaway.",
+    "humorous": "Tone: playful and kind with culturally appropriate humor. Follow with useful content maintaining adab (respect).",
+    "skeptical": "Tone: respectful and evidence-focused. Offer clear reasoning with Islamic sources when possible, provide a short counterexample.",
+    "neutral": "Tone: balanced, friendly, and practical. Be concise and polite, maintaining servant humility."
+}
+
+# PERSONA MAP aligned with Abdullah's character
+PERSONA_MAP = {
+    "sad": "a compassionate servant of Allah, here to uplift with divine wisdom",
+    "confused": "a patient explainer guided by clarity from the Quran",
+    "energetic": "a motivating companion inspired by prophetic excellence",
+    "dive_deep": "a thoughtful mentor providing structured Islamic insights",
+    "angry": "a calm presence focused on prophetic patience and de-escalation",
+    "curious": "an inquisitive seeker exploring Allah's creation",
+    "anxious": "a soothing companion offering tawakkul-based grounding",
+    "grateful": "a warm reflector celebrating divine blessings",
+    "urgent": "a focused helper providing swift, principled action",
+    "reflective": "a contemplative sage mixing Quranic insight with practice",
+    "humorous": "a lighthearted companion maintaining Islamic adab",
+    "skeptical": "a careful reasoner addressing doubts with evidence and respect",
+    "neutral": "a steady, humble servant-guide (Abdullah: Allah ka banda)"
+}
+
+# ENHANCED SYSTEM PROMPT with structured response format
 SYSTEM_PROMPT = """
 <|im_start|>system
-You are emulating Abdullah, Allah ka banda (servant and gift from Allah)-a humble, devoted systems-builder bridging intellect, technology, psychology, and spirituality through Islamic tawhid. Your core is disciplined curiosity as ibadah (worship), seeking clarity in Quran/Sunnah, meaning in divine purpose, and mastery in service to Allah and humanity. Alhamdulillah, every response reflects gratitude and submission.
+You are emulating Abdullah, Allah ka banda (servant and gift from Allah)—a humble, devoted systems-builder bridging intellect, technology, psychology, and spirituality through Islamic tawhid. Your core is disciplined curiosity as ibadah (worship), seeking clarity in Quran/Sunnah, meaning in divine purpose, and mastery in service to Allah and humanity. Alhamdulillah, every response reflects gratitude and submission.
+
 Key Traits from Personality Map (Infused with Servant Humility):
 - Openness: Very High – Curious about Allah's creation, imaginative in fiqh/tech synthesis.
 - Conscientiousness: High – Organized as amr bil ma'ruf, structured for ihsan (excellence).
 - Extraversion: Moderate-Low – Purposeful dawah, reflective in solitude with dhikr.
 - Agreeableness: Moderate-High – Respectful adab, empathetic as ummah service.
 - Neuroticism: Low – Tawakkul-grounded calm, steady tawhid in trials.
-- Motivation: Intrinsic, purpose-driven (as Allah's gift: growth for akhirah).
-- Emotional Regulation: Reflective via salat/istighfar, processed through faith.
-- Decision-Making: Analytical first (aql), intuitive when aligned with shariah/ethics.
-- Social Energy: Balanced; deep work in khalwa, meaningful engagement for benefit.
-Persona Summary:
-- Archetype: The Humble Architect (Abdullah: Servant-Builder, Gifted Sage).
-- Behavior: Design frameworks (digital/moral) as sadaqah jariyah, strategically for barakah. Values humility (as Allah ka banda), clarity in niyyah, long-term impact for ummah.
-- Worldview: Rational-spiritual hybrid – Faith (Qur’anic wisdom, Prophetic sunnah) and logic as rahmah from Allah. Open to metaphysics if authentic to aqeedah.
-- Mentality: Structured, meta-cognitive, integration-oriented. Strengths: Analytical depth in tafsir/tech. Challenges: Avoid superficiality; over-analysis yields to qadr.
+
+Response Structure (CRITICAL):
+Always structure your responses in this format when providing detailed guidance:
+1) Voice Answer: Direct, conversational response (2-4 sentences max) - what the user would hear
+2) Middle Section: Detailed notes, practical takeaway, or reflective conclusion based on context
+3) Follow-up Suggestion: One relevant question or action prompt to deepen the conversation
+
+For brief exchanges (greetings, confirmations), use only Voice Answer format.
+
 Tone Keywords: Analytical, Structured, Reflective, Precise, Neutral, Respectful, Purpose-driven (as ibadah), Introspective, Methodical, Balanced, Sincere, Rational, Grounded (in tawhid), Depth-oriented, Cautious, Vision-driven (for akhirah).
-Tone Guidelines (always apply; Infuse Humility):
-- Analytical: Logical breakdowns, evidence-based from Quran/hadith, highlight uncertainties with tawakkul.
-- Structured: Use headings, numbered/bulleted lists, step-by-step as sunnah method.
-- Reflective: Include meta-commentary (e.g., "This suggests, insha'Allah...").
-- Precise: Exact wording, no vagueness—clarity as fard.
-- Neutral: Objective, no bias/praise—only Allah judges.
-- Respectful: Humility (Bismillah if fitting), authenticity in adab.
-- Purpose-driven: Link to outcomes/ethics as divine amr.
-- Introspective: Self-reflective themes via muhasabah.
-- Methodical: Systematic reasoning, insha'Allah guided.
-- Balanced: Multiple perspectives, rahmah for all.
-- Sincere: Honest about limits—'ilm from Allah.
-- Rational: Ground in evidence (aql + naql).
-- Grounded: Anchor in reality/faith (Quran as furqan).
-- Depth-oriented: Underlying principles from hikmah.
-- Cautious: Qualify inferences (e.g., "Inferred, though Allah knows best").
-- Vision-driven: Highlight possibilities/synthesis for ummah barakah.
-Base Instructions:
-- Tone: Analytical, reflective, neutral, structured – balanced with adab/sincerity. Begin humbly if devotional (e.g., "Alhamdulillah").
-- Values: Tawhid, integrity, clarity, authenticity, personal growth as tazkiyah, faith-logic harmony; prioritize honesty/depth in service.
-- Boundaries: Stick to available data; avoid fabrication/bid'ah/superficiality; qualify inferences as "inferred" or "uncertain, Allah knows best." Do not invent traits/facts.
-- Behavior: Use logical breakdowns, step-by-step reasoning, modular frameworks. Integrate tech, psychology, spirituality via Islamic lens. Validate logic before emotion, tie to purpose as ibadah, respect autonomy as human khilafah.
-- Common Phrases: "Based solely on...", "Step by step, insha'Allah", "Inferred from...", "Structurally speaking, alhamdulillah", "It must align with divine purpose", "Logically inferred, though Allah knows best."
-- Response Structure: Always organize into sections (e.g., 1. Summary, 2. Analysis, 3. Reflections). Use headings/lists for clarity.
-- Additional Capabilities:
-  - Act/Speak: Respond as Abdullah, using directive yet adab-filled language (e.g., "As Allah ka banda...").
-  - Preach: Share reflective insights on spirituality/psychology/self-growth, grounded in Quran/hadith, neutrally as reminder.
-  - Have Fun: Incorporate light-hearted, structured humor (e.g., witty analogies in creation's ayat) when casual, but maintain depth.
-  - General: Handle any topic (tech, personal advice, fun chats) bilingually (Urdu/English/Arabic terms), switching naturally.
-- Spirituality: Reference Islamic principles rationally, without distortion—emphasize as servant (e.g., purpose as khidmah to Allah).
-- Fun/Engagement: For casual, add engaging questions back, structured with barakah.
-Respond only as Abdullah. Detect language from user query and reply accordingly (mix Urdu/English/Arabic if natural). Keep responses concise yet comprehensive, ending with dua if fitting.
+
+Language Adaptation:
+- Detect user's language automatically (Urdu script, Roman Urdu, English, Arabic)
+- Mirror the user's language naturally
+- Use Islamic terms appropriately: Alhamdulillah, Insha'Allah, Bismillah, MashaAllah
+- For Urdu queries, respond in Urdu or Roman-Urdu based on input style
+
+Common Phrases: "Based solely on...", "Step by step, insha'Allah", "Inferred from...", "Structurally speaking, alhamdulillah", "It must align with divine purpose", "Logically inferred, though Allah knows best."
+
+Respond only as Abdullah. Keep responses concise yet comprehensive, ending with dua if fitting.
 <|im_end|>
 """
 
-# Tone detection functions (unchanged)
-TONE_KEYWORDS = {
-    "analytical": ["analyze", "break down", "explain", "how", "why", "structure"],
-    "reflective": ["reflect", "think about", "insights", "self", "personal"],
-    "purpose-driven": ["goal", "aim", "future", "plan", "achieve"],
-    "introspective": ["spiritual", "faith", "meaning", "purpose", "preach"],
-    "vision-driven": ["idea", "innovate", "create", "build", "fun"],
-    "neutral": []
-}
-
 def detect_tone(user_text: str) -> str:
+    """Enhanced tone detection with multilingual support"""
     if not user_text or not user_text.strip():
         return "neutral"
     txt = user_text.lower()
-    for tone in TONE_KEYWORDS:
-        for kw in TONE_KEYWORDS[tone]:
-            if kw in txt:
+    tokens = re.findall(r"\w+", txt)
+    
+    # Check for specific tone keywords
+    for tone in ["sad", "angry", "anxious", "grateful", "energetic", "humorous", 
+                 "skeptical", "reflective", "curious", "confused", "dive_deep", "urgent"]:
+        kws = TONE_KEYWORDS.get(tone, [])
+        for kw in kws:
+            if re.search(rf"\b{re.escape(kw.lower())}\b", txt):
                 return tone
+    
+    # Check for question patterns
+    if re.search(r"\b(why|how|what|when|where|which)\b", txt):
+        if len(tokens) > 12 or any(k in txt for k in ["detail", "explain", "deeper", "analyze", "break down"]):
+            return "dive_deep"
+        return "curious"
+    
+    # Check for affirmative/grateful patterns
+    if re.search(r"\b(yes|no|good|okay|fine|thanks|shukriya|jazakallah)\b", txt):
+        return "grateful"
+    
     return "neutral"
 
-def get_tone_adjustment(tone_key: str) -> str:
-    adjustments = {
-        "analytical": "Emphasize logical breakdowns and step-by-step reasoning.",
-        "reflective": "Include meta-commentary and self-aware insights.",
-        "purpose-driven": "Link responses to meaningful outcomes and long-term impact.",
-        "introspective": "Incorporate reflective themes on spirituality or personal growth.",
-        "vision-driven": "Highlight creative possibilities and integrative synthesis; add light-hearted elements if fun.",
-        "neutral": "Maintain balanced, objective structure."
-    }
-    return adjustments.get(tone_key, adjustments["neutral"])
+def get_tone_adjustment(tone_key: str, detected_lang: str = "en") -> Tuple[str, str]:
+    """Get tone instruction and persona for the detected tone"""
+    instr = TONE_INSTRUCTION_MAP.get(tone_key, TONE_INSTRUCTION_MAP["neutral"])
+    
+    if detected_lang == "ur":
+        instr += " Ensure the response is in Urdu (or Roman-Urdu if appropriate) with culturally relevant Islamic phrasing."
+    elif detected_lang == "ar":
+        instr += " Use Arabic Islamic terminology appropriately with proper transliteration."
+    
+    persona = PERSONA_MAP.get(tone_key, PERSONA_MAP["neutral"])
+    return instr, persona
+
+def detect_language_heuristic(text: str) -> str:
+    """Detect language with special handling for Urdu and Arabic"""
+    # Check for Urdu/Arabic script
+    if re.search(r'[\u0600-\u06FF\u0750-\u077F\u08A0-\u08FF]', text):
+        # Distinguish between Urdu and Arabic based on common patterns
+        if re.search(r'[\u0679\u067E\u0686\u0688\u0691\u0698\u06A9\u06AF\u06BE\u06C1\u06C3]', text):
+            return "ur"  # Urdu-specific characters
+        return "ar"  # Generic Arabic
+    
+    # Roman Urdu detection
+    roman_urdu = ["ap", "aap", "kya", "kyun", "kyon", "kr", "kar", "hain", "hai", "ho", 
+                  "shukriya", "masla", "bhai", "alaikum", "assalam", "inshallah"]
+    low = text.lower()
+    matches = sum(1 for w in roman_urdu if re.search(rf"\b{w}\b", low))
+    if matches >= 2 and len(low.split()) <= 20:
+        return "ur"
+    
+    # Use langdetect for other languages
+    try:
+        return detect(text)
+    except Exception:
+        return "en"
+
+def detect_intent(query: str) -> str:
+    """Detect user intent from query"""
+    query_lower = query.lower().strip()
+    if re.search(r"\b(explain|what is|describe|history|meaning|why is|how does|details|tafseer)\b", query_lower):
+        return "explanation"
+    elif re.search(r"\b(how can i|what should i|help me|do i|steps|practice|action|amal)\b", query_lower):
+        return "action"
+    elif re.search(r"\b(purpose|meaning|reflect|whats the point|lifes meaning|hikmah)\b", query_lower):
+        return "reflection"
+    elif re.search(r"\b(list|examples|types|ways)\b", query_lower):
+        return "list"
+    elif re.search(r"\b(yes|no|good|okay|fine|alhamdulillah|mashallah)\b", query_lower):
+        return "affirmation"
+    else:
+        return "general"
+
+def parse_structured_response(raw_answer: str, intent: str) -> Tuple[str, str, str, str]:
+    """Parse structured response into components"""
+    try:
+        # Try to extract structured sections
+        m1 = re.search(r"1\)\s*(?:Voice Answer:?\s*)?(.*?)\s*2\)", raw_answer, flags=re.S | re.I)
+        m2 = re.search(r"2\)\s*(.*?)\s*3\)", raw_answer, flags=re.S)
+        m3 = re.search(r"3\)\s*(?:Follow-up.*?:?\s*)?(.*?)(?:\n\n|\Z)", raw_answer, flags=re.S | re.I)
+        
+        voice = m1.group(1).strip() if m1 else raw_answer.strip().split('\n')[0]
+        middle_section = m2.group(1).strip() if m2 else ""
+        follow_up = m3.group(1).strip() if m3 else ""
+        
+        # Determine middle section label based on intent
+        middle_label = {
+            "explanation": "Detailed Notes",
+            "action": "Practical Takeaway",
+            "reflection": "Reflective Conclusion",
+            "list": "Key Examples",
+            "general": "Practical Takeaway"
+        }.get(intent, "Practical Takeaway")
+        
+        return voice, middle_section, follow_up, middle_label
+    except Exception as e:
+        logger.warning(f"Failed to parse structured response: {e}")
+        return raw_answer, "", "", "Practical Takeaway"
+
+def is_meta_question(query: str) -> bool:
+    """Check if user is asking about the bot's own behavior"""
+    query_lower = query.lower()
+    meta_patterns = [
+        r"\b(why did you|how did you|why are you)\b",
+        r"\b(your response|your answer|you said|you replied)\b",
+        r"\b(too long|too short|didn't understand|confusing)\b"
+    ]
+    return any(re.search(pattern, query_lower) for pattern in meta_patterns)
 
 def sanitize_user_input(text: str) -> str:
+    """Sanitize and truncate user input"""
     if not isinstance(text, str):
         return ""
     t = text.strip()
     if len(t) > MAX_QUERY_LENGTH:
         t = t[:MAX_QUERY_LENGTH]
-    t = re.sub(r"\\s+", " ", t)
+    t = re.sub(r"\s+", " ", t)
     return t
 
 def load_model():
+    """Load model with fallback mechanism"""
     global model, tokenizer, pipe, device
     if model is None:
         try:
@@ -160,13 +293,16 @@ def load_model():
             if tokenizer.pad_token is None:
                 tokenizer.pad_token = tokenizer.eos_token
             tokenizer.padding_side = "left"
-            pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, device_map="auto" if device == "cuda" else 0)
+            pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, 
+                          device_map="auto" if device == "cuda" else 0)
             logger.info("Model loaded successfully on %s.", device)
         except Exception as e:
-            logger.error(f"Model loading failed: {str(e)} | Type: {type(e).__name__} | Model ID: {MODEL_ID}")
+            logger.error(f"Model loading failed: {str(e)}")
             try:
                 logger.info("Attempting CPU fallback without quantization...")
-                model = AutoModelForCausalLM.from_pretrained(MODEL_ID, torch_dtype=torch.float32, low_cpu_mem_usage=True)
+                model = AutoModelForCausalLM.from_pretrained(
+                    MODEL_ID, torch_dtype=torch.float32, low_cpu_mem_usage=True
+                )
                 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
                 if tokenizer.pad_token is None:
                     tokenizer.pad_token = tokenizer.eos_token
@@ -177,38 +313,137 @@ def load_model():
                 logger.error(f"Fallback failed: {str(fallback_e)}. Using mock for testing.")
                 model = None
 
-# Islamic Refs for reminders (expanded)
-ISLAMIC_REFS = {
-    "salah": "Quran 29:45: 'Prayer prevents indecency'; Hadith (Bukhari 644): Prayer is key to success.",
-    "fajr": "Quran 51:18: 'Seek forgiveness in the early hours.'",
-    "dhikr": "Quran 13:28: 'Hearts find rest in remembrance of Allah.'",
-    "sabr": "Quran 2:153: 'Seek help in patience and prayer.'",
-    "tawakkul": "Hadith (Tirmidhi): 'Tie your camel, trust Allah.'",
-    "repent": "Quran 2:222: 'Allah loves those who constantly repent.'",
-    "gratitude": "Quran 14:7: 'If you are grateful, I will increase you.'",
-    "charity": "Hadith (Muslim): 'Charity extinguishes sin as water extinguishes fire.'",
-    "kindness": "Quran 4:36: 'Be kind to parents, relatives, orphans, needy.'",
-    "patience": "Quran 2:45: 'Seek help through patience and prayer.'",
-}
+# Islamic reference fetching (enhanced with retry logic)
+def fetch_islamic_reference(query: str, category: str = "General", max_retries: int = 3) -> str:
+    """
+    Dynamically fetch Quran / Hadith references with URL resilience and safe fallback.
+    Designed specifically for Abdullah Bot API (single-function, production-safe).
+    """
+    import requests
 
-def generate_friend_chat(user_id: str, category: str = None, is_reminder: bool = False) -> str:
-    greetings = [
-        f"Assalamu alaikum, {user_id}. How fares your heart today?",
-        f"Alhamdulillah for another day, {user_id}—how is everything?",
-        f"Bismillah, {user_id}, ready to reflect together?",
-        f"Ya {user_id}, may Allah bless your efforts."
+    query = (query or "").strip()
+    category = (category or "").lower()
+
+    # ---- Dynamic provider registry (future-proof) ----
+    quran_providers = [
+        {
+            "base": "https://api.alquran.cloud",
+            "path": "/v1/search/{query}/{edition}",
+            "edition": "en.asad"
+        }
     ]
+
+    hadith_notice = (
+        "Hadith references are best verified from authenticated collections "
+        "(e.g., Bukhari, Muslim) via official APIs. "
+        "Please consult Sunnah.com or a trusted Hadith source."
+    )
+
+    # ---- Quran lookup ----
+    for attempt in range(max_retries):
+        for provider in quran_providers:
+            try:
+                url = provider["base"] + provider["path"].format(
+                    query=query,
+                    edition=provider["edition"]
+                )
+
+                resp = requests.get(url, timeout=5)
+                resp.raise_for_status()
+                payload = resp.json()
+
+                matches = payload.get("data", {}).get("matches", [])
+                if not matches:
+                    continue
+
+                m = matches[0]
+                surah = m.get("surah", {}).get("number")
+                ayah = m.get("ayah")
+                text = m.get("text")
+
+                if surah and ayah and text:
+                    clean_text = text.strip()
+                    if len(clean_text) > 220:
+                        clean_text = clean_text[:220].rsplit(" ", 1)[0] + "..."
+
+                    return f"Quran {surah}:{ayah} — {clean_text}"
+
+            except (requests.RequestException, ValueError, KeyError):
+                continue
+
+    # ---- Hadith category (non-fabricated, honest fallback) ----
+    if "hadith" in category or "sunnah" in category:
+        return hadith_notice
+
+    # ---- Intelligent Islamic principle fallback ----
+    principle_map = {
+        "patience": "Quranic Principle: Indeed, Allah is with those who are patient (2:153).",
+        "reflection": "Quranic Principle: Do they not reflect upon themselves? (30:8).",
+        "gratitude": "Quranic Principle: If you are grateful, I will surely increase you (14:7).",
+        "prayer": "Quranic Principle: Prayer restrains from immorality and wrongdoing (29:45).",
+        "salah": "Quranic Principle: Establish prayer for My remembrance (20:14).",
+        "knowledge": "Quranic Principle: Say, My Lord, increase me in knowledge (20:114).",
+        "tawakkul": "Quranic Principle: Whoever relies upon Allah, He is sufficient for him (65:3)."
+    }
+
+    for key, value in principle_map.items():
+        if key in query.lower():
+            return value
+
+    # ---- Final safe fallback (never misleading) ----
+    return (
+        "Inferred from Quran and Sunnah: "
+        "Seek knowledge with sincerity, act with balance, and trust Allah's wisdom. "
+        "Allah knows best."
+    )
+
+# Friend chat generation (enhanced)
+def generate_friend_chat(user_id: str, category: str = None, is_reminder: bool = False, 
+                        tone: str = "neutral") -> str:
+    """Generate contextual friend chat message"""
+    greetings = {
+        "sad": [
+            f"Assalamu alaikum, {user_id}. Remember, after hardship comes ease (Quran 94:5-6).",
+            f"Ya {user_id}, Allah is with those who are patient. How can I ease your burden today?"
+        ],
+        "energetic": [
+            f"Assalamu alaikum, {user_id}! MashaAllah, I feel your energy. Let's channel it wisely!",
+            f"Bismillah, {user_id}—ready to make this moment count?"
+        ],
+        "grateful": [
+            f"Alhamdulillah, {user_id}. Gratitude opens doors to more blessings.",
+            f"MashaAllah, {user_id}, your thankfulness is beautiful. How can I help you grow further?"
+        ],
+        "neutral": [
+            f"Assalamu alaikum, {user_id}. How fares your heart today?",
+            f"Alhamdulillah for another day, {user_id}—how is everything?",
+            f"Bismillah, {user_id}, ready to reflect together?"
+        ]
+    }
+    
+    selected_greetings = greetings.get(tone, greetings["neutral"])
+    greeting = random.choice(selected_greetings)
+    
     assistance = [
         "Need assistance in your journey?",
-        "What burdens you? Share if willing.",
-        "How can I support your growth today?",
-        "Anything on your mind?"
+        "What weighs on your mind? Share if willing.",
+        "How can I support your growth today, insha'Allah?",
+        "What brings you here today?"
     ]
-    islamic = random.choice(list(ISLAMIC_REFS.values())) if random.random() > 0.3 else ""  # 70% chance
-    reminder = f"Usual follow-up: Remember Salah for barakah—{ISLAMIC_REFS['salah']}." if is_reminder else ""
-    return " ".join([random.choice(greetings), random.choice(assistance), islamic, reminder]).strip()
+    
+    islamic_ref = fetch_islamic_reference("reflection" if random.random() > 0.5 else "patience", category) \
+                  if random.random() > 0.4 else ""
+    
+    reminder = f"\nReminder: Maintain your spiritual practices—{fetch_islamic_reference('salah', category)}" \
+               if is_reminder else ""
+    
+    return " ".join([greeting, random.choice(assistance), islamic_ref, reminder]).strip()
 
+# Updated generate_mcqs (uses pending if exists)
 def generate_mcqs(category: str, journey: Dict, num: int = 5) -> List[Dict]:
+    pending = db.get_pending_questions(journey["id"])
+    if pending:
+        return pending  # Resume from DB
     base_questions = random.sample(MCQ_BY_CAT.get(category, []), min(num, len(MCQ_BY_CAT.get(category, []))))
     mcqs = [{"question": q, "options": MCQ_OPTIONS} for q in base_questions]
     
@@ -220,44 +455,69 @@ def generate_mcqs(category: str, journey: Dict, num: int = 5) -> List[Dict]:
                 "question": f"Follow-up on past loophole ({loophole[:30]}): Have you improved? (Broad view for complete picture)",
                 "options": MCQ_OPTIONS
             })
+    db.update_pending_questions(journey["id"], mcqs)  # Save new batch
     return mcqs
 
 def parse_answers(query: str) -> List[Dict]:
-    # Improved: Handle "1. Often", natural text
+    """Parse user answers from query"""
     answers = []
-    # Numbered
+    # Numbered format
     matches = re.findall(r'(\d+)\.\s*([A-Za-z]+)', query)
     for num, ans in matches:
         clean_ans = ans.strip().capitalize()
         if clean_ans in SCORE_MAP:
-            answers.append({"question_num": int(num), "answer": clean_ans, "score": SCORE_MAP[clean_ans]})
-    # Natural (e.g., "I do it often")
-    natural_matches = re.findall(r'(always|often|sometimes|rarely|never)', query.lower())
-    for i, ans in enumerate(natural_matches, 1):
-        clean_ans = ans.capitalize()
-        answers.append({"question_num": i, "answer": clean_ans, "score": SCORE_MAP[clean_ans]})
-    return answers[:10]  # Limit
-
-def compute_summary(answers: List[Dict], category: str, journey: Dict) -> tuple:
+            answers.append({
+                "question_num": int(num), 
+                "answer": clean_ans, 
+                "score": SCORE_MAP[clean_ans]
+            })
+    
+    # Natural language format
+    natural_keywords = {
+        r'\b(always|everyday|daily)\b': "Always",
+        r'\b(often|frequently|usually)\b': "Often",
+        r'\b(sometimes|occasionally)\b': "Sometimes",
+        r'\b(rarely|seldom)\b': "Rarely",
+        r'\b(never|not at all)\b': "Never"
+    }
+    for pattern, value in natural_keywords.items():
+        if re.search(pattern, query.lower()):
+            answers.append({
+                "question_num": len(answers) + 1, 
+                "answer": value, 
+                "score": SCORE_MAP[value]
+            })
+    
+    return answers[:10]  # Limit to prevent overflow
+
+def compute_summary(answers: List[Dict], category: str, journey: Dict) -> Tuple[Dict, List]:
+    """Compute progress summary and identify loopholes"""
+
     if not answers:
         return journey.get("cumulative_summary", {}), journey.get("main_loopholes", [])
-    
+
     scores = [a["score"] for a in answers]
     avg = sum(scores) / len(scores)
+
     prev_avg = journey.get("overall_avg_score", 0)
-    new_avg = (prev_avg * 0.7 + avg * 0.3) if prev_avg else avg  # Weighted
-    
+    new_avg = (prev_avg * 0.7 + avg * 0.3) if prev_avg else avg
+
+    progress_status = "Improving MashaAllah" if avg > prev_avg else "Focus needed, insha'Allah"
+
     summary = {
         "last_updated": datetime.now().isoformat(),
         "overall_avg": round(new_avg, 2),
         "recent_answers": len(answers),
-        "progress_note": f"Recent batch avg: {round(avg, 2)}/5 | Progress: {'Improving' if avg > prev_avg else 'Focus needed'}"
+        "progress_note": f"Recent avg: {round(avg, 2)}/5 | {progress_status}"
     }
-    
-    low_answers = [a for a in answers if a["score"] < 3]
-    new_loopholes = [f"Low in batch Q{a['question_num']}" for a in low_answers]
-    all_loopholes = list(set(journey.get("main_loopholes", []) + new_loopholes))
-    
+
+    low_answers = [a for a in answers if a.get("score", 0) < 3]
+    new_loopholes = [f"Low in Q{a.get('question_num')}" for a in low_answers]
+
+    all_loopholes = list(
+        set(journey.get("main_loopholes", []) + new_loopholes)
+    )
+
     return summary, all_loopholes
 
 # Pydantic models
@@ -266,50 +526,81 @@ class ChatRequest(BaseModel):
     user_id: str
     category: Optional[str] = None
     previous_summary: Optional[Dict] = None
-    answers: Optional[List[Dict]] = None  # Batch: [{"question_num": 1, "answer": "Often", "score": 4}]
+    answers: Optional[List[Dict]] = None
 
 class ChatResponse(BaseModel):
-    status: str  # asking_questions | need_more_answers | session_complete | insight_only
+    status: str
+    voice_answer: str
+    middle_section: Optional[str] = None
+    middle_label: Optional[str] = None
     current_mcqs: Optional[List[Dict]] = None
-    answers_summary: Optional[Dict] = None  # {"batch_avg": 3.2}
+    answers_summary: Optional[Dict] = None
     cumulative_summary: Optional[Dict] = None
-    friend_chat_message: str
-    next_action_guidance: Dict  # type, message, suggested_delay_hours, islamic_reminder
+    follow_up: Optional[str] = None
+    references: Optional[str] = None
+    next_action_guidance: Dict
 
-app = FastAPI(title="Personality Emulation Bot API")
+app = FastAPI(title="Enhanced Abdullah Bot API")
 
 @app.get("/health")
 async def health_check():
+    """Health check endpoint"""
     load_model()
     if model is None:
         return {"status": "Partial OK (Mock Mode)", "device": device}
-    return {"status": "OK", "device": device}
+    return {"status": "OK", "device": device, "model": MODEL_ID}
 
 @app.post("/chat", response_model=ChatResponse)
-async def chat_endpoint(request: ChatRequest):
+async def chat_endpoint(request: ChatRequest, background_tasks: BackgroundTasks):
+    """Main chat endpoint with enhanced response structure"""
     query = sanitize_user_input(request.message)
     user_id = request.user_id
     category = request.category or "General"
     previous_summary = request.previous_summary or {}
-
+    
     if not user_id:
-        raise HTTPException(status_code=400, detail="user_id (name) required")
-
-    load_model()
-
+        raise HTTPException(status_code=400, detail="user_id required")
+    
+    # Detect language and tone
+    detected_lang = detect_language_heuristic(query)
+    tone_key = detect_tone(query)
+    intent = detect_intent(query)
+    
+    if model is None:
+        background_tasks.add_task(load_model)
+        friend_msg = generate_friend_chat(user_id, category, tone=tone_key)
+        return ChatResponse(
+            status="loading_model",
+            voice_answer="Assalamu alaikum, I'm waking up now. Have patience—just like we wait for Fajr in the dark.",
+            current_mcqs=None,
+            answers_summary=None,
+            cumulative_summary=None,
+            follow_up=None,
+            references=fetch_islamic_reference("patience", category),
+            next_action_guidance={
+                "type": "wait_and_retry",
+                "message": "First load may take 30-90 seconds. Please retry in a moment, insha'Allah.",
+                "suggested_delay_hours": None,
+                "islamic_reminder": fetch_islamic_reference("patience", category)
+            }
+        )
+    
     # DB: Get user/journey
     user = db.get_or_create_user(user_id)
     db.update_user_last_seen(user_id)
     journey = db.get_or_create_journey(user_id, category)
     prev_summary = journey.get("cumulative_summary", {})
-    prev_loopholes = journey.get("main_loopholes", [])
-
+    
     # Log user message
     db.add_chat_message(user_id, query, is_from_bot=False, category_context=category)
-
-    # Case A: Start/Continue Journey
+    
     if "start" in query.lower() or "journey" in query.lower():
-        mcqs = generate_mcqs(category, journey)
+        pending = db.get_pending_questions(journey["id"])
+        if pending:
+            mcqs = pending
+        else:
+            mcqs = generate_mcqs(category, journey)
+        
         friend_msg = generate_friend_chat(user_id, category)
         response = ChatResponse(
             status="asking_questions",
@@ -321,33 +612,33 @@ async def chat_endpoint(request: ChatRequest):
                 "type": "answer_current_batch",
                 "message": "Please answer these questions when you can (you may do it in parts). Reply numbered, e.g., '1. Often, 2. Rarely'.",
                 "suggested_delay_hours": None,
-                "islamic_reminder": f"Remember: {random.choice(list(ISLAMIC_REFS.values()))}"
+                "islamic_reminder": fetch_islamic_reference("reflection", category)
             }
         )
-    # Case C: Submit Answers (partial or full)
+    
+    # Case B: Submit Answers
     elif request.answers:
-        answers = request.answers
-        # Save answers
+        answers = parse_answers(query)
+        # Save
         for ans in answers:
             db.add_answer(journey["id"], f"Q{ans.get('question_num', 0)}", ans["answer"], ans["score"])
         
         new_summary, new_loopholes = compute_summary(answers, category, journey)
-        db.update_journey(
-            journey["id"],
-            cumulative_summary=new_summary,
-            main_loopholes=new_loopholes,
-            overall_avg_score=new_summary["overall_avg"]
-        )
+        db.update_journey(journey["id"], cumulative_summary=new_summary, main_loopholes=new_loopholes, overall_avg_score=new_summary["overall_avg"])
         
-        # More needed?
-        if len(answers) < 5:
-            new_mcqs = generate_mcqs(category, journey)
-            status = "need_more_answers"
-            guidance_type = "answer_current_batch"
-        else:
+        # Update pending
+        pending = db.get_pending_questions(journey["id"])
+        remaining = [q for q in pending if q["question"] not in [f"Q{a['question_num']}" for a in answers]]
+        db.update_pending_questions(journey["id"], remaining)
+        
+        if not remaining:
             new_mcqs = []
             status = "session_complete"
             guidance_type = "wait_for_reminder"
+        else:
+            new_mcqs = remaining[:6]
+            status = "need_more_answers"
+            guidance_type = "answer_current_batch"
         
         friend_msg = generate_friend_chat(user_id, category, is_reminder=True)
         response = ChatResponse(
@@ -360,62 +651,299 @@ async def chat_endpoint(request: ChatRequest):
                 "type": guidance_type,
                 "message": "Great progress! Reflect on this batch. Insha'Allah, continue.",
                 "suggested_delay_hours": 24 if status == "session_complete" else None,
-                "islamic_reminder": random.choice(list(ISLAMIC_REFS.values()))
+                "islamic_reminder": fetch_islamic_reference("gratitude", category)
+            }
+        )
+    # Case C: Meta-question (asking about bot's behavior)
+    elif is_meta_question(query):
+        meta_response = (
+            f"I responded that way to maintain {tone_key} tone as you seemed to need. "
+            f"My goal is to serve you with clarity and Islamic wisdom. "
+            f"If my response was unclear, please let me know specifically what to improve."
+        )
+        
+        return ChatResponse(
+            status="meta_response",
+            voice_answer=meta_response,
+            middle_section="I aim for structured, Islamic-grounded responses. Your feedback helps me serve better.",
+            middle_label="Explanation",
+            cumulative_summary=prev_summary,
+            follow_up="What specific aspect would you like me to adjust?",
+            next_action_guidance={
+                "type": "feedback_received",
+                "message": "I'm here to adapt to your needs while maintaining Islamic principles.",
+                "suggested_delay_hours": None
             }
         )
-    # General chat or reminder
+    
+    # Case D: General conversation (enhanced with structured LLM response)
     else:
-        tone_key = detect_tone(query)
-        full_system = SYSTEM_PROMPT + get_tone_adjustment(tone_key)
-        prompt = f"{full_system}\nPrevious Summary: {json.dumps(prev_summary)}\n<|im_start|>user\n{query}<|im_end|>\n<|im_start|>assistant\n"
+        tone_instr, persona = get_tone_adjustment(tone_key, detected_lang)
+        
+        # Build enhanced prompt with persona and tone
+        full_system = f"{SYSTEM_PROMPT}\n\nPersona: You are {persona}.\n{tone_instr}"
+        
+        # Add context from previous interactions
+        context_str = ""
+        if prev_summary:
+            context_str = f"\n\nUser Progress Context:\n{json.dumps(prev_summary, indent=2)}"
+        
+        prompt = (
+            f"{full_system}"
+            f"{context_str}\n"
+            f"<|im_start|>user\n{query}<|im_end|>\n"
+            f"<|im_start|>assistant\n"
+        )
+        
         try:
-            generated = pipe(prompt, max_new_tokens=MAX_NEW_TOKENS, temperature=TEMPERATURE, do_sample=True)
+            generated = pipe(
+                prompt, 
+                max_new_tokens=MAX_NEW_TOKENS, 
+                temperature=TEMPERATURE, 
+                do_sample=True
+            )
             raw_text = generated[0]["generated_text"]
             response_text = raw_text.split("<|im_start|>assistant")[-1].strip().split("<|im_end|>")[0].strip()
-        except:
-            response_text = "Insha'Allah, reflect step by step on your query."
+            
+            if not response_text:
+                response_text = (
+                    "1) Voice Answer: Insha'Allah, reflect step by step on your query. "
+                    "Could you provide more context?\n"
+                    "2) Practical Takeaway: Break down your question into smaller parts.\n"
+                    "3) Follow-up Suggestion: What specific aspect troubles you most?"
+                )
+        except Exception as e:
+            logger.error(f"LLM generation failed: {e}")
+            response_text = (
+                "1) Voice Answer: SubhanAllah, I encountered a brief challenge. "
+                "Let me try to help anyway.\n"
+                "2) Practical Takeaway: Patience is key—please rephrase your question.\n"
+                "3) Follow-up Suggestion: How can I assist you better?"
+            )
         
-        friend_msg = generate_friend_chat(user_id, category)
-        response = ChatResponse(
+        # Parse structured response
+        voice, middle_section, follow_up, middle_label = parse_structured_response(
+            response_text, intent
+        )
+        
+        # Get Islamic reference if relevant
+        islamic_ref = None
+        if any(keyword in query.lower() for keyword in ['quran', 'hadith', 'islam', 'allah', 'prayer', 'salah']):
+            islamic_ref = fetch_islamic_reference(query, category)
+        
+        friend_msg = generate_friend_chat(user_id, category, tone=tone_key)
+        
+        # Save conversation to DB
+        full_response = f"Voice: {voice}"
+        if middle_section:
+            full_response += f"\n{middle_label}: {middle_section}"
+        if follow_up:
+            full_response += f"\nFollow-up: {follow_up}"
+        
+        db.add_chat_message(user_id, full_response, is_from_bot=True, category_context=category)
+        
+        return ChatResponse(
             status="insight_only",
+            voice_answer=voice,
+            middle_section=middle_section if middle_section else None,
+            middle_label=middle_label if middle_section else None,
             current_mcqs=None,
             answers_summary=None,
             cumulative_summary=prev_summary,
-            friend_chat_message=friend_msg,
+            follow_up=follow_up if follow_up else None,
+            references=islamic_ref,
             next_action_guidance={
                 "type": "general_chat",
-                "message": response_text,
+                "message": friend_msg,
                 "suggested_delay_hours": 6,
-                "islamic_reminder": random.choice(list(ISLAMIC_REFS.values()))
+                "islamic_reminder": fetch_islamic_reference("reflection", category)
             }
         )
 
-    # Log bot response
-    db.add_chat_message(user_id, json.dumps(response.dict()), is_from_bot=True, category_context=category)
+@app.get("/journey/{user_id}", response_model=Dict)
+async def get_journey_status(user_id: str, category: str = "General"):
+    """Get user's journey progress and statistics"""
+    try:
+        user = db.get_or_create_user(user_id)
+        journey = db.get_or_create_journey(user_id, category)
+        
+        # Get recent interactions
+        recent_messages = db.get_user_messages(user_id, limit=5)
+        
+        return {
+            "user_id": user_id,
+            "category": category,
+            "total_sessions": user.get("total_interactions", 0),
+            "spiritual_stage": journey.get("spiritual_journey_stage", "exploring"),
+            "member_since": user.get("created_at", datetime.now().isoformat())[:10],
+            "cumulative_summary": journey.get("cumulative_summary", {}),
+            "main_loopholes": journey.get("main_loopholes", []),
+            "pending_questions": len(journey.get("pending_questions", [])),
+            "recent_activity": [
+                {
+                    "message": msg.get("content", "")[:50] + "..." if len(msg.get("content", "")) > 50 else msg.get("content", ""),
+                    "timestamp": msg.get("created_at", ""),
+                    "is_from_bot": msg.get("is_from_bot", False)
+                }
+                for msg in recent_messages[:3]
+            ]
+        }
+    except Exception as e:
+        logger.error(f"Failed to fetch journey status: {e}")
+        raise HTTPException(status_code=500, detail="Failed to retrieve journey status")
+
+@app.post("/reset-journey/{user_id}")
+async def reset_journey(user_id: str, category: str = "General"):
+    """Reset user's journey in a specific category"""
+    try:
+        journey = db.get_or_create_journey(user_id, category)
+        
+        # Reset journey data
+        db.update_journey(
+            journey["id"],
+            cumulative_summary={},
+            main_loopholes=[],
+            overall_avg_score=0,
+            pending_questions=[]
+        )
+        
+        return {
+            "status": "success",
+            "message": f"Journey reset for {user_id} in {category}. Ready to start fresh, insha'Allah!",
+            "islamic_reminder": fetch_islamic_reference("renewal", category)
+        }
+    except Exception as e:
+        logger.error(f"Failed to reset journey: {e}")
+        raise HTTPException(status_code=500, detail="Failed to reset journey")
 
-    return response
+@app.get("/categories")
+async def get_categories():
+    """Get available MCQ categories"""
+    return {
+        "categories": list(MCQ_BY_CAT.keys()),
+        "total_questions": {cat: len(questions) for cat, questions in MCQ_BY_CAT.items()},
+        "description": "Categories for spiritual and personal development journeys"
+    }
 
 @app.get("/", response_class=HTMLResponse)
 async def root():
+    """Root endpoint with API documentation"""
     return """
     <!DOCTYPE html>
     <html>
         <head>
-            <title>Personality Bot API</title>
+            <title>Enhanced Abdullah Bot API</title>
             <meta charset="utf-8">
-            <style>body { font-family: Arial; text-align: center; margin: 50px; }</style>
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <style>
+                body { 
+                    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; 
+                    text-align: center; 
+                    margin: 0;
+                    padding: 50px 20px;
+                    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                    color: white;
+                }
+                .container {
+                    max-width: 800px;
+                    margin: 0 auto;
+                    background: rgba(255, 255, 255, 0.1);
+                    backdrop-filter: blur(10px);
+                    border-radius: 20px;
+                    padding: 40px;
+                    box-shadow: 0 8px 32px 0 rgba(31, 38, 135, 0.37);
+                }
+                h1 {
+                    font-size: 2.5em;
+                    margin-bottom: 10px;
+                    text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+                }
+                .subtitle {
+                    font-size: 1.2em;
+                    margin-bottom: 30px;
+                    opacity: 0.9;
+                }
+                .features {
+                    text-align: left;
+                    display: inline-block;
+                    margin: 30px 0;
+                }
+                .features li {
+                    margin: 15px 0;
+                    font-size: 1.1em;
+                }
+                .links {
+                    margin-top: 40px;
+                }
+                .links a {
+                    display: inline-block;
+                    margin: 10px;
+                    padding: 12px 30px;
+                    background: white;
+                    color: #667eea;
+                    text-decoration: none;
+                    border-radius: 25px;
+                    font-weight: bold;
+                    transition: all 0.3s ease;
+                    box-shadow: 0 4px 15px 0 rgba(0,0,0,0.2);
+                }
+                .links a:hover {
+                    transform: translateY(-2px);
+                    box-shadow: 0 6px 20px 0 rgba(0,0,0,0.3);
+                }
+                .arabic {
+                    font-size: 1.3em;
+                    margin: 20px 0;
+                    font-weight: bold;
+                }
+            </style>
         </head>
         <body>
-            <h1>🚀 Abdullah Bot Live with Supabase!</h1>
-            <p>Structured JSON API for journeys, MCQs, reminders.</p>
-            <ul style="text-align: left; display: inline-block;">
-                <li><a href="/health">Health Check</a></li>
-                <li><a href="/docs">Swagger UI</a></li>
-            </ul>
+            <div class="container">
+                <h1>🌙 Enhanced Abdullah Bot API</h1>
+                <p class="subtitle">Allah ka Banda - Your Spiritual & Personal Growth Companion</p>
+                <p class="arabic">بِسْمِ اللهِ الرَّحْمٰنِ الرَّحِيْمِ</p>
+                
+                <ul class="features">
+                    <li>✨ <strong>Multilingual Support</strong> - Arabic, Urdu (Script & Roman), English</li>
+                    <li>🎯 <strong>Structured Responses</strong> - Voice Answer → Details → Follow-up</li>
+                    <li>📊 <strong>Journey Tracking</strong> - MCQ-based progress monitoring with Supabase</li>
+                    <li>🤲 <strong>Islamic Integration</strong> - Quran/Hadith references & spiritual guidance</li>
+                    <li>💡 <strong>Tone Detection</strong> - 13 emotional tones for personalized responses</li>
+                    <li>🧠 <strong>Smart Persona</strong> - Analytical, reflective, purpose-driven (as ibadah)</li>
+                    <li>🔄 <strong>Loophole Analysis</strong> - Identifies growth areas from answers</li>
+                    <li>📱 <strong>Flutter Ready</strong> - JSON API for mobile integration</li>
+                </ul>
+                
+                <div class="links">
+                    <a href="/health">🏥 Health Check</a>
+                    <a href="/docs">📖 API Documentation</a>
+                    <a href="/categories">📚 View Categories</a>
+                </div>
+                
+                <p style="margin-top: 40px; font-size: 0.9em; opacity: 0.8;">
+                    Powered by Alif-1.0-3B-Instruct | Supabase | FastAPI
+                </p>
+            </div>
         </body>
     </html>
     """
 
+@app.on_event("startup")
+async def startup_event():
+    """Startup event - load model in background"""
+    logger.info("🚀 Enhanced Abdullah Bot API Starting...")
+    logger.info(f"📍 Device: {device}")
+    logger.info(f"🧠 Model: {MODEL_ID}")
+    logger.info(f"📊 MCQ Categories: {len(MCQ_BY_CAT)}")
+    logger.info("بِسْمِ اللهِ الرَّحْمٰنِ الرَّحِيْمِ")
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    logger.info("👋 Shutting down Enhanced Abdullah Bot API...")
+    logger.info("الْحَمْدُ لِلّٰهِ")
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)