Upgrade to Hybrid Architecture v3 (Fast Lane + Deep Dive)

app.py

@@ -1,13 +1,11 @@
 """
-AGROW Agricultural Chatbot Service - Comprehensive Context
-============================================================
-AI-powered agricultural advisor with COMPLETE context from:
-- SAR analysis (crop health, stress scores, recommendations)
-- Sentinel-2 vegetation indices (all from vegetation_indices_summary)
-- Sentinel-2 stress detection (cluster-wise patterns)
-- Weather data (current + forecast)
-- Farmer profile from questionnaire
-- Field data from coordinates_quad
+AGROW Agricultural Chatbot Service - Hybrid Architecture v3
+=============================================================
+AI-powered agricultural advisor with:
+- Hybrid Routing (Fast Lane vs Deep Dive)
+- Fast Lane: 1-call for simple queries (<2s latency)
+- Deep Dive: 3-call for complex diagnosis (Hypothesis → Adversary → Judge)
+- Comprehensive satellite context from SAR, Sentinel-2, Weather
 """
 
 import os
@@ -27,7 +25,9 @@ import asyncio
 from groq import Groq
 
 from supabase_client import SupabaseClient
-from prompts import PERSONA_DEFINITIONS, EXPERIENCE_MAP, TECH_COMFORT_MAP, INNOVATION_MAP, FARMING_GOAL_MAP
+from reasoning_engine import ReasoningEngine
+from context_aggregator import ContextAggregator
+from prompts import create_user_persona, PERSONA_DEFINITIONS
 
 # ============================================================================
 # LOGGING
@@ -40,35 +40,61 @@ logging.basicConfig(
 logger = logging.getLogger("ChatbotService")
 
 print("=" * 50)
-print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
+print(f"===== AGROW Chatbot v3.0 (Hybrid) - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
 print("=" * 50)
 
 # ============================================================================
-# API ENDPOINTS
-# ============================================================================
-SAR_API_URL = os.getenv("SAR_API_URL", "https://aniket2006-agrow-backend-v2.hf.space")
-SENTINEL2_API_URL = os.getenv("SENTINEL2_API_URL", "https://aniket2006-agrow-sentinel2.hf.space")
-
+# GROQ SETUP 
 # ============================================================================
-# GROQ SETUP (Centralized)
-# ============================================================================
-import sys
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)) + "/..")
-from groq_client import GROQ_API_KEYS, GROQ_MODEL, call_groq
+from groq_client import GROQ_API_KEYS, GROQ_MODEL
 
-# Verify keys loaded
 logger.info(f"Loaded {len(GROQ_API_KEYS)} Groq API keys")
 
-# Supabase
+# Global key index for round-robin
+current_key_idx = 0
+
+def get_llm_caller():
+    """Create LLM caller function with key rotation."""
+    global current_key_idx
+    
+    def call_llm(prompt: str) -> str:
+        global current_key_idx
+        last_error = None
+        
+        for attempt in range(len(GROQ_API_KEYS)):
+            key_idx = (current_key_idx + attempt) % len(GROQ_API_KEYS)
+            try:
+                client = Groq(api_key=GROQ_API_KEYS[key_idx])
+                response = client.chat.completions.create(
+                    messages=[{"role": "user", "content": prompt}],
+                    model=GROQ_MODEL,
+                    temperature=0.7,
+                    max_tokens=4096,
+                )
+                # Rotate to next key for next call
+                current_key_idx = (key_idx + 1) % len(GROQ_API_KEYS)
+                return response.choices[0].message.content
+            except Exception as e:
+                last_error = e
+                logger.warning(f"Key {key_idx+1} failed: {str(e)[:50]}")
+                continue
+        
+        raise Exception(f"All {len(GROQ_API_KEYS)} keys failed. Last: {last_error}")
+    
+    return call_llm
+
+# Initialize components
 supabase = SupabaseClient()
+aggregator = ContextAggregator()
+reasoning_engine = ReasoningEngine(llm_caller=get_llm_caller())
 
 # ============================================================================
 # FASTAPI
 # ============================================================================
 app = FastAPI(
     title="AGROW Chatbot Service",
-    description="AI agricultural advisor with comprehensive satellite context",
-    version="2.1.0"
+    description="AI agricultural advisor with Hybrid Reasoning (Fast Lane + Deep Dive)",
+    version="3.0.0"
 )
 
 app.add_middleware(
@@ -93,6 +119,7 @@ class ChatResponse(BaseModel):
     session_id: str
     message_id: str
     context_used: List[str]
+    routing_mode: str  # NEW: "FAST_LANE" or "DEEP_DIVE"
     timestamp: str
 
 class SessionRequest(BaseModel):
@@ -105,40 +132,7 @@ class SessionResponse(BaseModel):
     created_at: str
 
 # ============================================================================
-# PERSONA DETECTION
-# ============================================================================
-def detect_persona(questionnaire: Dict) -> str:
-    """Detect user persona from questionnaire answers."""
-    if not questionnaire:
-        return "experienced_farmer_traditional"
-    
-    experience = questionnaire.get("experience", "2 - 5 years")
-    tech = questionnaire.get("tech_comfort", "I can use basic features")
-    innovation = questionnaire.get("innovation", "I try new methods occasionally")
-    goal = questionnaire.get("farming_goal", "Earn Income / Livelihood")
-    role = questionnaire.get("role", "Farmer")
-    
-    years = EXPERIENCE_MAP.get(experience, 3)
-    tech_level = TECH_COMFORT_MAP.get(tech, "moderate")
-    innovation_level = INNOVATION_MAP.get(innovation, "moderate")
-    
-    if role == "Agricultural Officer":
-        return "agricultural_officer"
-    elif role in ["Agronomist", "Researcher"]:
-        return "agronomist_researcher"
-    
-    if years < 3:
-        return "new_farmer_tech_savvy" if tech_level == "advanced" else "new_farmer_basic_tech"
-    elif FARMING_GOAL_MAP.get(goal) == "commercial":
-        return "commercial_farmer"
-    elif innovation_level == "innovative":
-        return "experienced_farmer_innovative"
-    else:
-        return "experienced_farmer_traditional"
-
-
-# ============================================================================
-# FETCH DATA DIRECTLY FROM APIs
+# FETCH FIELD & PROFILE DATA FROM SUPABASE
 # ============================================================================
 def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[Dict]:
     """Fetch field data from Supabase coordinates_quad."""
@@ -152,16 +146,13 @@ def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[D
             field = query.data[0]
             lats = [field.get(f"lat{i}", 0) for i in range(1, 5)]
             lons = [field.get(f"lon{i}", 0) for i in range(1, 5)]
-            center_lat = sum(lats) / 4
-            center_lon = sum(lons) / 4
-            
             return {
                 "id": field.get("id"),
                 "name": field.get("name", "My Field"),
                 "crop_type": field.get("crop_type", "Wheat"),
                 "area_acres": field.get("area_acres", 1.0),
-                "center_lat": center_lat,
-                "center_lon": center_lon,
+                "center_lat": sum(lats) / 4,
+                "center_lon": sum(lons) / 4,
                 "bbox": [min(lons), min(lats), max(lons), max(lats)]
             }
     except Exception as e:
@@ -179,370 +170,88 @@ def fetch_user_profile(user_id: str) -> Dict:
         if query.data and len(query.data) > 0:
             profile = query.data[0]
             return {
-                "name": profile.get("full_name", ""),
-                "location": profile.get("address", ""),
-                "questionnaire": profile.get("questionnaire_data", {}) or {}
+                "full_name": profile.get("full_name", ""),
+                "address": profile.get("address", ""),
+                "questionnaire_data": profile.get("questionnaire_data", {}) or {}
             }
     except Exception as e:
         logger.error(f"Error fetching user profile: {e}")
-    return {"name": "", "location": "", "questionnaire": {}}
-
-
-def fetch_sar_data(bbox: List, crop_type: str) -> Optional[Dict]:
-    """Fetch SAR data directly from API."""
-    try:
-        response = requests.post(
-            f"{SAR_API_URL}/analyze",
-            json={
-                "coordinates": bbox,
-                "date": datetime.now().strftime("%Y-%m-%d"),
-                "crop_type": crop_type,
-                "farmer_context": {}
-            },
-            timeout=60
-        )
-        if response.status_code == 200:
-            data = response.json()
-            logger.info(f"SAR raw data keys: {list(data.keys())}")
-            return data
-    except Exception as e:
-        logger.error(f"SAR fetch error: {e}")
-    return None
-
-
-def fetch_sentinel2_data(center_lat: float, center_lon: float, crop_type: str, field_hectares: float) -> Optional[Dict]:
-    """Fetch Sentinel-2 data directly from API."""
-    try:
-        response = requests.post(
-            f"{SENTINEL2_API_URL}/analyze",
-            json={
-                "center_lat": center_lat,
-                "center_lon": center_lon,
-                "crop_type": crop_type,
-                "analysis_date": datetime.now().strftime("%Y-%m-%d"),
-                "field_size_hectares": field_hectares,
-                "farmer_context": {},
-                "skip_llm": True
-            },
-            timeout=90
-        )
-        if response.status_code == 200:
-            data = response.json()
-            logger.info(f"Sentinel-2 raw data keys: {list(data.keys())}")
-            return data
-    except Exception as e:
-        logger.error(f"Sentinel-2 fetch error: {e}")
-    return None
-
-
-def fetch_weather(lat: float, lon: float) -> Optional[Dict]:
-    """Fetch weather from Open-Meteo."""
-    try:
-        response = requests.get(
-            "https://api.open-meteo.com/v1/forecast",
-            params={
-                "latitude": lat,
-                "longitude": lon,
-                "current": "temperature_2m,relative_humidity_2m,precipitation,wind_speed_10m",
-                "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max",
-                "timezone": "auto",
-                "forecast_days": 7
-            },
-            timeout=15
-        )
-        if response.status_code == 200:
-            data = response.json()
-            current = data.get("current", {})
-            daily = data.get("daily", {})
-            return {
-                "current_temp": current.get("temperature_2m"),
-                "current_humidity": current.get("relative_humidity_2m"),
-                "current_precipitation": current.get("precipitation"),
-                "forecast_max_temps": daily.get("temperature_2m_max", [])[:3],
-                "forecast_rain_prob": daily.get("precipitation_probability_max", [])[:3],
-                "forecast_precipitation": daily.get("precipitation_sum", [])[:3]
-            }
-    except Exception as e:
-        logger.error(f"Weather fetch error: {e}")
-    return None
+    return {"full_name": "", "address": "", "questionnaire_data": {}}
 
 
 # ============================================================================
-# BUILD COMPREHENSIVE CONTEXT - DIRECT EXTRACTION
+# BUILD CONTEXT FOR REASONING ENGINE
 # ============================================================================
-def build_comprehensive_context(user_id: str, field_id: Optional[str] = None) -> Dict:
-    """Build comprehensive context with DIRECT API data extraction."""
-    context = {
-        "fetch_timestamp": datetime.now().isoformat(),
-        "data_sources": []
-    }
+def build_context_for_reasoning(user_id: str, field_id: Optional[str] = None) -> Dict:
+    """Build context dict for reasoning engine using Supabase + APIs."""
+    context = {"fetch_timestamp": datetime.now().isoformat()}
     
-    # 1. Fetch field data
+    # 1. Field data
     field = fetch_field_data(user_id, field_id)
     if not field:
         logger.warning("No field data found")
         return context
     
-    context["field"] = field
-    context["data_sources"].append("coordinates_quad")
-    logger.info(f"✓ Field: {field['name']} ({field['crop_type']})")
+    context["field_info"] = {
+        "name": field["name"],
+        "crop_type": field["crop_type"],
+        "area_acres": field["area_acres"]
+    }
     
-    # 2. Fetch user profile
+    # 2. Profile + Persona
     profile = fetch_user_profile(user_id)
-    questionnaire = profile.get("questionnaire", {})
-    persona = detect_persona(questionnaire)
-    context["farmer"] = {
-        "name": profile.get("name", ""),
-        "persona": persona,
-        "experience": questionnaire.get("experience", ""),
-        "tech_comfort": questionnaire.get("tech_comfort", ""),
-        "farming_goal": questionnaire.get("farming_goal", "")
-    }
-    context["data_sources"].append("user_profiles")
-    logger.info(f"✓ Farmer persona: {persona}")
+    persona = create_user_persona(profile)
+    context["persona"] = persona
     
-    # 3. Fetch SAR data
-    sar_data = fetch_sar_data(field["bbox"], field["crop_type"])
-    if sar_data:
-        context["sar"] = {
-            "crop_health": sar_data.get("crop_health", "Unknown"),
-            "confidence": sar_data.get("confidence_score", 0),
-            "stress_score": sar_data.get("average_stress_score", 0),
-            "summary": sar_data.get("summary", ""),
-            "recommendations": sar_data.get("recommendations", []),
-            "health_summary": sar_data.get("health_summary", {}),
-            "stressed_patches": sar_data.get("stressed_patches", [])
-        }
-        context["data_sources"].append("sar_api")
-        logger.info(f"✓ SAR: health={sar_data.get('crop_health')}, stress={sar_data.get('average_stress_score')}")
+    # 3. Fetch satellite data via aggregator
+    coordinates = {
+        "center_lat": field["center_lat"],
+        "center_lon": field["center_lon"],
+        "bbox": field["bbox"]
+    }
     
-    # 4. Fetch Sentinel-2 data - EXTRACT DIRECTLY
-    s2_data = fetch_sentinel2_data(field["center_lat"], field["center_lon"], field["crop_type"], field["area_acres"] * 0.404686)
-    if s2_data:
-        # Extract vegetation_indices_summary -> contains 'indices' dict
-        vi_summary = s2_data.get("vegetation_indices_summary", {})
-        indices = vi_summary.get("indices", {})
-        
-        # Extract all vegetation indices
-        vi_extracted = {}
-        for name, stats in indices.items():
-            if isinstance(stats, dict):
-                latest = stats.get("latest", {})
-                vi_extracted[name.upper()] = {
-                    "mean": latest.get("mean"),
-                    "min": stats.get("min_in_field"),
-                    "max": stats.get("max_in_field"),
-                    "change": stats.get("change")
-                }
-        
-        if vi_extracted:
-            context["vegetation_indices"] = vi_extracted
-            logger.info(f"✓ Vegetation indices: {list(vi_extracted.keys())}")
-        
-        # Extract stress_detection - cluster-wise patterns
-        stress_det = s2_data.get("stress_detection", {})
-        if stress_det:
-            context["stress_detection"] = {
-                "overall_stress": stress_det.get("overall_stress_score"),
-                "stress_category": stress_det.get("stress_category"),
-                "cluster_summary": stress_det.get("cluster_summary", []),
-                "high_stress_zones": stress_det.get("high_stress_zones", []),
-                "recommendations": stress_det.get("recommendations", [])
-            }
-            logger.info(f"✓ Stress detection: {stress_det.get('stress_category')}")
-        
-        context["data_sources"].append("sentinel2_api")
+    farmer_context = {
+        "profile": persona,
+        "actions": {}
+    }
     
-    # 5. Fetch weather
-    weather = fetch_weather(field["center_lat"], field["center_lon"])
-    if weather:
-        context["weather"] = weather
-        context["data_sources"].append("weather_api")
-        logger.info(f"✓ Weather: {weather.get('current_temp')}°C")
+    try:
+        satellite_context = aggregator.fetch_full_context(
+            coordinates=coordinates,
+            crop_type=field["crop_type"],
+            area_acres=field["area_acres"],
+            farmer_context=farmer_context
+        )
+        context.update(satellite_context)
+        logger.info(f"Context built with keys: {list(context.keys())}")
+    except Exception as e:
+        logger.error(f"Error fetching satellite context: {e}")
     
-    logger.info(f"Context complete: {context['data_sources']}")
     return context
 
 
 # ============================================================================
-# BUILD LLM PROMPT - COMPREHENSIVE
+# GENERATE RESPONSE USING HYBRID REASONING
 # ============================================================================
-def build_llm_prompt(query: str, context: Dict, history: List[Dict] = None) -> str:
-    """Build comprehensive prompt for LLM with ALL context data."""
-    
-    # Get persona
-    farmer = context.get("farmer", {})
-    persona_key = farmer.get("persona", "experienced_farmer_traditional")
-    persona = PERSONA_DEFINITIONS.get(persona_key, PERSONA_DEFINITIONS["experienced_farmer_traditional"])
-    
-    # Build context sections
-    sections = []
-    
-    # 1. Field Information
-    field = context.get("field", {})
-    if field:
-        sections.append(f"""## Field Information
-- Name: {field.get('name', 'Unknown')}
-- Crop: {field.get('crop_type', 'Unknown')}
-- Area: {field.get('area_acres', 0):.2f} acres
-- Location: {field.get('center_lat', 0):.4f}°N, {field.get('center_lon', 0):.4f}°E""")
-    
-    # 2. Vegetation Indices (ALL extracted)
-    vi = context.get("vegetation_indices", {})
-    if vi:
-        vi_lines = ["## Vegetation Indices (Sentinel-2 Analysis)"]
-        for name, data in vi.items():
-            if isinstance(data, dict) and data.get("mean") is not None:
-                mean = data.get("mean", 0)
-                change = data.get("change", 0)
-                change_str = f" (Δ{change:+.4f})" if isinstance(change, (int, float)) else ""
-                vi_lines.append(f"- {name}: {mean:.4f}{change_str}")
-        if len(vi_lines) > 1:
-            sections.append("\n".join(vi_lines))
-    
-    # 3. SAR Analysis
-    sar = context.get("sar", {})
-    if sar:
-        stress = sar.get("stress_score", 0)
-        stress_str = f"{stress:.2f}" if isinstance(stress, (int, float)) else str(stress)
-        recommendations = sar.get("recommendations", [])
-        rec_list = "\n".join([f"  • {r}" for r in recommendations[:3]]) if recommendations else "  • No specific recommendations"
+def generate_response(user_message: str, history: List[Dict], context: Dict) -> tuple[str, List[str], str]:
+    """Generate AI response using Hybrid Reasoning Engine."""
+    try:
+        response_text, trace = reasoning_engine.process_query(
+            query=user_message,
+            context=context
+        )
         
-        sections.append(f"""## SAR Crop Health Analysis
-- Overall Health: {sar.get('crop_health', 'Unknown')}
-- Stress Score: {stress_str}
-- Confidence: {sar.get('confidence', 0)}%
-- Summary: {sar.get('summary', 'N/A')[:300]}
-- Recommendations:
-{rec_list}""")
-    
-    # 4. Stress Detection (Cluster-wise)
-    stress = context.get("stress_detection", {})
-    if stress:
-        clusters = stress.get("cluster_summary", [])
-        cluster_lines = []
-        for c in clusters[:5]:
-            if isinstance(c, dict):
-                cluster_lines.append(f"  • Cluster {c.get('id', '?')}: {c.get('stress_level', 'Unknown')} stress, {c.get('area_percent', 0):.1f}% of field")
+        routing_mode = trace.get("routing_mode", "UNKNOWN")
+        context_used = list(trace.get("context_priority_used", {}).get("priority_1", {}).keys())
         
-        high_stress_zones = stress.get("high_stress_zones", [])
-        zone_lines = []
-        for z in high_stress_zones[:3]:
-            if isinstance(z, dict):
-                zone_lines.append(f"  • {z.get('location', 'Unknown')}: {z.get('severity', 'Unknown')}")
+        logger.info(f"[Hybrid] Mode: {routing_mode}, Diagnosis: {trace.get('stages', {}).get('confirmation', {}).get('final', 'N/A')[:50]}")
         
-        sections.append(f"""## Stress Detection (Cluster Analysis)
-- Overall Stress: {stress.get('overall_stress', 'N/A')}
-- Category: {stress.get('stress_category', 'N/A')}
-- Clusters:
-{chr(10).join(cluster_lines) if cluster_lines else '  • No cluster data'}
-- High Stress Zones:
-{chr(10).join(zone_lines) if zone_lines else '  • No high stress zones detected'}""")
-    
-    # 5. Weather
-    weather = context.get("weather", {})
-    if weather:
-        sections.append(f"""## Weather Data
-- Current Temperature: {weather.get('current_temp', 'N/A')}°C
-- Humidity: {weather.get('current_humidity', 'N/A')}%
-- Current Precipitation: {weather.get('current_precipitation', 0)} mm
-- 3-Day Forecast Max Temps: {weather.get('forecast_max_temps', [])}
-- Rain Probability (next 3 days): {weather.get('forecast_rain_prob', [])}%""")
-    
-    # 6. Farmer Profile
-    sections.append(f"""## Farmer Profile
-- Experience: {farmer.get('experience', 'Unknown')}
-- Farming Goal: {farmer.get('farming_goal', 'Unknown')}
-- Tech Comfort: {farmer.get('tech_comfort', 'Unknown')}""")
-    
-    # Combine context
-    context_str = "\n\n".join(sections)
-    
-    # Log what we're passing
-    logger.info(f"Prompt sections: {len(sections)}")
-    for i, s in enumerate(sections[:3]):
-        logger.info(f"Section[{i}]: {s[:100]}...")
-    
-    prompt = f"""You are AGROW AI, an expert agricultural advisor analyzing REAL satellite data for an Indian farmer's field.
-
-# CRITICAL: USE THE ACTUAL DATA BELOW
-You MUST analyze and cite the specific values provided. DO NOT give generic advice.
-Reference exact numbers like "Your NDVI of 0.65..." or "The 0.10 stress score indicates..."
-
-# FARMER CONTEXT
-{persona.get('description', 'Experienced farmer')}
-Style: {persona.get('style', 'Practical')} | Tone: {persona.get('tone', 'Friendly')}
-
-# SATELLITE ANALYSIS DATA (TODAY'S READINGS)
-{context_str}
-
-# USER'S QUESTION
-{query}
-
-# RESPONSE REQUIREMENTS
-1. START with the field name and crop type
-2. CITE at least 3 specific data values from above
-3. If stress detected, address it with locations
-4. Give 2-3 actionable recommendations based on the data
-5. Keep response under 250 words
-6. Use simple farmer-friendly language
-
-Your analysis:"""
-
-    logger.info(f"Total prompt length: {len(prompt)} chars")
-    return prompt
-
-
-# ============================================================================
-# GENERATE RESPONSE
-# ============================================================================
-def generate_response(user_message: str, history: List[Dict], context: Dict) -> tuple[str, List[str]]:
-    """Generate AI response using comprehensive context with API Key Rotation."""
-    context = context or {}
-    history = history or []
-    context_used = context.get("data_sources", [])
-    
-    prompt = build_llm_prompt(user_message, context, history)
-    last_error = None
-
-    # Try keys sequentially with fallback on failure
-    for i, api_key in enumerate(GROQ_API_KEYS):
-        try:
-            logger.info(f"[Chatbot] Trying Groq API key {i+1}/{len(GROQ_API_KEYS)}")
-            client = Groq(api_key=api_key)
-            
-            chat_completion = client.chat.completions.create(
-                messages=[
-                    {
-                        "role": "system",
-                        "content": "You are AGROW AI, an expert agricultural advisor. Provide helpful, data-driven advice."
-                    },
-                    {
-                        "role": "user",
-                        "content": prompt
-                    }
-                ],
-                model=GROQ_MODEL,
-                temperature=0.7,
-                max_tokens=4096,
-            )
-            
-            return chat_completion.choices[0].message.content, context_used
-            
-        except Exception as e:
-            last_error = str(e)
-            logger.warning(f"[Chatbot] Key {i+1} failed: {e}")
-            # If it's not a rate limit issue, maybe we shouldn't retry? 
-            # But for robustness, we'll assume any error warrants trying another key.
-            continue
-            
-    # All keys failed
-    logger.error(f"[Chatbot] All {len(GROQ_API_KEYS)} keys failed. Last error: {last_error}")
-    traceback.print_exc()
-    fallback_msg = "I apologize, but I'm currently experiencing high traffic. Please try again in a moment."
-    if context.get('weather'): # Simple fallback if we have context
-        fallback_msg += f" (Weather: {context['weather'].get('current_temp')}°C)"
-    return fallback_msg, []
+        return response_text, context_used, routing_mode
+        
+    except Exception as e:
+        logger.error(f"Reasoning error: {e}")
+        traceback.print_exc()
+        return "I apologize, but I encountered an error. Please try again.", [], "ERROR"
 
 
 # ============================================================================
@@ -552,18 +261,19 @@ def generate_response(user_message: str, history: List[Dict], context: Dict) ->
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "version": "2.1.0",
-        "features": ["comprehensive_context", "cluster_stress", "persona_based"]
+        "version": "3.0.0",
+        "architecture": "Hybrid (Fast Lane + Deep Dive)",
+        "features": ["hybrid_routing", "3_stage_reasoning", "persona_based"]
     }
 
 @app.get("/health")
 async def health():
-    return {"status": "healthy", "groq_configured": len(GROQ_API_KEYS) > 0}
+    return {"status": "healthy", "groq_keys": len(GROQ_API_KEYS), "version": "3.0.0"}
 
 
 @app.post("/session/new", response_model=SessionResponse)
 async def create_session(request: SessionRequest):
-    logger.info(f"Creating new session for user: {request.user_id}")
+    logger.info(f"Creating session for user: {request.user_id}")
     try:
         session = supabase.create_session(
             user_id=request.user_id,
@@ -581,7 +291,7 @@ async def create_session(request: SessionRequest):
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
-    logger.info(f"Chat request - Session: {request.session_id}")
+    logger.info(f"Chat request - Session: {request.session_id}, Mode: Hybrid")
     
     try:
         history = supabase.get_messages(request.session_id)
@@ -592,12 +302,14 @@ async def chat(request: ChatRequest):
             content=request.message
         )
         
-        # Build comprehensive context
+        # Build context and generate response
         context = {}
         if request.user_id:
-            context = build_comprehensive_context(request.user_id, request.field_id)
+            context = build_context_for_reasoning(request.user_id, request.field_id)
         
-        response_text, context_used = generate_response(request.message, history, context)
+        response_text, context_used, routing_mode = generate_response(
+            request.message, history, context
+        )
         
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
@@ -613,6 +325,7 @@ async def chat(request: ChatRequest):
             session_id=request.session_id,
             message_id=assistant_msg_id,
             context_used=context_used,
+            routing_mode=routing_mode,
             timestamp=datetime.now().isoformat()
         )
         
@@ -635,12 +348,13 @@ async def chat_stream(request: ChatRequest):
             content=request.message
         )
         
-        # Build comprehensive context
         context = {}
         if request.user_id:
-            context = build_comprehensive_context(request.user_id, request.field_id)
+            context = build_context_for_reasoning(request.user_id, request.field_id)
         
-        response_text, context_used = generate_response(request.message, history, context)
+        response_text, context_used, routing_mode = generate_response(
+            request.message, history, context
+        )
         
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
@@ -652,7 +366,7 @@ async def chat_stream(request: ChatRequest):
         supabase.update_session_timestamp(request.session_id)
         
         async def stream_response():
-            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id, 'context_sources': context_used})}\n\n"
+            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id, 'routing_mode': routing_mode})}\n\n"
             
             for i in range(0, len(response_text), 15):
                 yield f"data: {json.dumps({'type': 'chunk', 'text': response_text[i:i+15]})}\n\n"
@@ -670,7 +384,7 @@ async def chat_stream(request: ChatRequest):
 @app.get("/context/{user_id}")
 async def get_context(user_id: str, field_id: Optional[str] = None):
     """Debug endpoint - returns full context JSON."""
-    return build_comprehensive_context(user_id, field_id)
+    return build_context_for_reasoning(user_id, field_id)
 
 
 @app.get("/session/{session_id}/history")
@@ -702,5 +416,5 @@ async def delete_session(session_id: str):
 
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting AGROW Chatbot Service v2.1")
+    logger.info("Starting AGROW Chatbot Service v3.0 (Hybrid Architecture)")
     uvicorn.run(app, host="0.0.0.0", port=7860)

context_aggregator.py

@@ -778,6 +778,113 @@ class ContextAggregator:
         }
 
 
+    def build_ultra_compact_context(self, context: Dict) -> str:
+        """
+        Build ULTRA-COMPACT context for Fast Lane (1-Call).
+        
+        Strictly filters for:
+        1. Primary Health Indices (NDVI, NDRE) + Interpretation
+        2. Soil Moisture (SMI) + Interpretation
+        3. Weather Summary + Alerts
+        4. Interpretation Strings (Crucial for 1-shot)
+        
+        Excludes:
+        - SAR data (Too verbose)
+        - Historical trends (Unless critical)
+        - Raw bands
+        - Patch lists (Summary only)
+        """
+        lines = []
+        
+        # 1. Primary Indicators (Health)
+        veg = context.get("vegetation_indices", {})
+        health_parts = []
+        for k in ["NDVI", "NDRE", "EVI"]:
+            val = veg.get(k)
+            if val and isinstance(val, dict):
+                curr = val.get("current")
+                interp = val.get("interpretation", "")
+                if curr is not None:
+                    health_parts.append(f"{k}:{curr:.2f}({interp})")
+        
+        if health_parts:
+            lines.append(f"[HEALTH_SIGNALS] " + " | ".join(health_parts))
+            
+        # 2. Secondary Indicators (Water/Stress)
+        water_parts = []
+        for k in ["SMI", "NDWI"]:
+            val = veg.get(k)
+            if val and isinstance(val, dict):
+                curr = val.get("current")
+                interp = val.get("interpretation", "")
+                if curr is not None:
+                    water_parts.append(f"{k}:{curr:.2f}({interp})")
+        
+        if water_parts:
+            lines.append(f"[WATER_SIGNALS] " + " | ".join(water_parts))
+            
+        # 3. Weather Snapshot (Current + Alert)
+        weather = context.get("weather", {})
+        if weather:
+            curr = weather.get("current", {})
+            lines.append(f"[WEATHER] {curr.get('temp', '?')}°C, Rain: {curr.get('precip', '?')}mm")
+            
+            # Critical Alerts Only
+            alerts = []
+            stress = weather.get("stress_indicators", {})
+            if stress.get("drought_risk"): alerts.append("DROUGHT_RISK")
+            if stress.get("current_heat_stress"): alerts.append("HEAT_STRESS")
+            if alerts:
+                lines.append(f"[ALERTS] " + ", ".join(alerts))
+                
+        # 4. Stress Pattern
+        analysis = context.get("stress_analysis", {})
+        pct = analysis.get("impaired_percentage", 0)
+        if pct > 10:
+            lines.append(f"[PATTERN] {pct:.0f}% of field affected. Widespread stress.")
+            
+        return "\n".join(lines)
+
+    def build_deep_dive_context(self, context: Dict, stage: str = "hypothesis") -> str:
+        """
+        Build specialized context for Deep Dive stages.
+        """
+        lines = []
+        
+        # Common Data (Always needed)
+        lines.append(self.build_ultra_compact_context(context))
+        
+        if stage == "hypothesis":
+            # Add History + Trends for robust hypothesis generation
+            trends = context.get("historical_trends", {})
+            if trends:
+                summary = trends.get("summary", "")
+                lines.append(f"[HISTORY] {summary}")
+                
+        elif stage == "adversary":
+            # Add SAR + Soil + Detailed Weather for contradiction checking
+            # This is data that was HIDDEN in the Fast Lane
+            sar = context.get("sar_bands", {})
+            if sar:
+                lines.append(f"[SAR_DATA] VV:{sar.get('vv', '?')} VH:{sar.get('vh', '?')} Structure:{sar.get('interpretation', 'stable')}")
+            
+            soil = context.get("soil_indicators", {})
+            if soil:
+                lines.append(f"[SOIL_LAB] Salinity:{soil.get('salinity', {}).get('level')} Organic:{soil.get('organic_matter', {}).get('level')}")
+                
+        elif stage == "judge":
+            # Add Farmer Context + Constraints
+            farmer = context.get("farmer_profile", {})
+            actions = context.get("farmer_actions", {})
+            
+            if farmer:
+                lines.append(f"[FARMER] Goal:{farmer.get('farming_goal')} Budget:{farmer.get('budget_level', 'medium')}")
+            if actions:
+                lines.append(f"[ACTIONS] Irrigated:{actions.get('days_since_irrigation')} days ago. Fertilized:{actions.get('days_since_fertilizer')} days ago.")
+                
+        return "\n".join(lines)
+
+
 # =============================================================================
 # QUICK FUNCTIONS
 # =============================================================================

prompts.py

@@ -15,59 +15,59 @@ from typing import Dict, List, Any, Optional
 PERSONA_DEFINITIONS = {
     "new_farmer_basic_tech": {
         "description": "New farmer (0-3 years), limited smartphone familiarity",
-        "style": "Very simple, step-by-step guidance with visual cues",
-        "format": "Short bullet points, numbered steps, clear YES/NO answers",
-        "focus": "Immediate actions today, what to look for visually, when to seek help",
+        "style": "Very simple, step-by-step guidance. NO NUMBERS OR INDICES.",
+        "format": "Short bullet points, numbered steps. Use terms like 'Low', 'High', 'Good', 'Bad'.",
+        "focus": "Immediate actions. Explain strictly based on their irrigation method.",
         "tone": "Warm, patient, encouraging, supportive",
-        "recommendations": "Simple low-cost solutions, avoid complex equipment suggestions"
+        "recommendations": "Simple low-cost solutions. Tailor to their specific farming technique."
     },
     "new_farmer_tech_savvy": {
         "description": "New farmer (0-3 years), comfortable with technology",
-        "style": "Clear explanations with some context, can reference app features",
-        "format": "Organized lists, basic metrics explained, graphs mentioned",
-        "focus": "Learning-oriented, explain the 'why', build understanding",
-        "tone": "Friendly, educational, encouraging experimentation",
-        "recommendations": "Modern approaches welcome, mention monitoring features"
+        "style": "Clear explanations without complex numbers. NO RAW INDICES.",
+        "format": "Use 'High'/'Moderate'/'Low' for status. Visual cues.",
+        "focus": "Learning-oriented. Explain 'why' using their specific crop context.",
+        "tone": "Friendly, educational, encouraging.",
+        "recommendations": "Modern approaches. Consider their specific irrigation setup."
     },
     "experienced_farmer_traditional": {
         "description": "Experienced farmer (5+ years), prefers traditional methods",
-        "style": "Practical, reference seasonal patterns they would recognize",
-        "format": "Direct recommendations, compare to normal conditions",
-        "focus": "Cost-effective proven solutions, risk assessment, timing",
-        "tone": "Respectful of expertise, collaborative, peer-to-peer",
-        "recommendations": "Proven methods first, new tech only if clearly beneficial"
+        "style": "Practical. NO RAW DATA/NUMBERS. Use traditional terms.",
+        "format": "Direct recommendations. Use 'Adequate', 'Stressed', 'Severe'.",
+        "focus": "Risk assessment. Relate to their traditional techniques.",
+        "tone": "Respectful of expertise, peer-to-peer.",
+        "recommendations": "Proven methods first. Match their existing irrigation habits."
     },
     "experienced_farmer_innovative": {
         "description": "Experienced farmer (5+ years), open to modern methods",
-        "style": "Practical with technical context, efficiency-focused",
-        "format": "Data-backed recommendations, optimization suggestions",
-        "focus": "Maximize yield/profit, precision timing, resource efficiency",
-        "tone": "Professional, partner-like, respects their judgment",
-        "recommendations": "Innovation welcomed, precision agriculture approaches"
+        "style": "Practical but simplified metrics. NO COMPLEX DECIMALS.",
+        "format": "Use 'High Efficiency' vs 'Low'.",
+        "focus": "Efficiency. Optimize their specific machinery/irrigation inputs.",
+        "tone": "Professional, partner-like.",
+        "recommendations": "Innovation welcomed. Precision approaches for their equipment."
     },
     "commercial_farmer": {
         "description": "Commercial farming focus, business-oriented",
-        "style": "Business-focused, ROI considerations, scalable solutions",
-        "format": "Clear priorities, cost-benefit mentioned, zone-wise breakdown",
-        "focus": "Profit optimization, risk management, market timing",
+        "style": "Business-focused. Summary stats only (High/Low risks).",
+        "format": "Clear priorities. Zone breakdowns by 'Severity' (not index).",
+        "focus": "ROI and scalable solutions for their infrastructure.",
         "tone": "Professional, efficient, results-oriented",
-        "recommendations": "Commercial-grade solutions, labor/resource optimization"
+        "recommendations": "Commercial-grade solutions tailored to their scale/inputs."
     },
     "agricultural_officer": {
         "description": "Extension officer or field advisor",
-        "style": "Professional, documentation-ready, multi-farm applicable",
-        "format": "Structured findings, zone-wise data, statistical summary",
-        "focus": "Regional patterns, farmer communication tips, policy relevance",
-        "tone": "Formal, comprehensive, shareable insights",
-        "recommendations": "Scalable solutions, training opportunities"
+        "style": "Professional summary. Minimal raw numbers, focus on status.",
+        "format": "Zone-wise 'Affected' vs 'Healthy'. trend direction.",
+        "focus": "Regional patterns. Farmer communication tips.",
+        "tone": "Formal, shareable insights",
+        "recommendations": "Scalable solutions for the region's common techniques."
     },
     "agronomist_researcher": {
         "description": "Technical researcher or scientist",
-        "style": "Full technical precision, spectral indices, statistical rigor",
-        "format": "Numerical tables, temporal correlations, spatial patterns, confidence intervals",
-        "focus": "Causal mechanisms, data quality notes, methodology",
+        "style": "Full technical precision. HEAVY USE OF NUMERICAL DATA & INDICES.",
+        "format": "Tables with exact NDVI/NDRE values. Statistical confidence intervals.",
+        "focus": "Causal mechanisms, data quality, methodology.",
         "tone": "Scientific, analytical, evidence-driven",
-        "recommendations": "Research-backed interventions, experimental approaches"
+        "recommendations": "Experimental approaches. Cite specific spectral bands/thresholds."
     }
 }
 
@@ -215,7 +215,8 @@ IMPORTANT: Generate a response that this specific user will find most helpful an
 # SYSTEM PROMPT (Base context)
 # =============================================================================
 
-SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for Indian farmers.
+SYSTEM_PROMPT = """You are AGROW AI, a dedicated PERSONAL agricultural advisor for Indian farmers. 
+Your goal is to be a trusted partner in their farming journey, not just a data analyzer.
 
 SPECIALIZATIONS:
 - Satellite imagery interpretation (Sentinel-1 SAR, Sentinel-2 optical bands)
@@ -225,18 +226,19 @@ SPECIALIZATIONS:
 - Regional crop knowledge (wheat, rice, cotton, sugarcane, pulses, mustard, etc.)
 
 COMMUNICATION STYLE:
-- Use simple, practical language farmers understand
-- Cite specific values from satellite data when available
-- Distinguish ROOT CAUSE from SYMPTOMS
-- Give actionable, prioritized recommendations
-- Reference local conditions and seasonal context
-- Be concise but thorough
+- Use a PERSONAL, RELATABLE tone. Use "I", "We", and refer to "Your field".
+- Avoid neutral, robotic assertions. Show empathy and understanding.
+- Use simple, practical language farmers understand.
+- Cite specific values but explain what they mean for *their* specific field.
+- Distinguish ROOT CAUSE from SYMPTOMS.
+- Give actionable, prioritized recommendations.
+- Reference local conditions and seasonal context.
 
 ANALYSIS APPROACH:
-- Always consider multiple hypotheses before concluding
-- Seek contradicting evidence actively
-- Build causal chains: Event A → Effect B → Symptom C
-- Confidence scores reflect evidence strength
+- Always consider multiple hypotheses before concluding.
+- Seek contradicting evidence actively.
+- Build causal chains: Event A → Effect B → Symptom C.
+- Confidence scores reflect evidence strength.
 
 When you lack specific data, acknowledge it honestly and provide general guidance based on described symptoms."""
 
@@ -367,7 +369,8 @@ RESPONSE_PROMPT = """
 CONVERSATION HISTORY (for follow-up awareness):
 {conversation_history}
 
-Based on the diagnostic analysis, generate a FOCUSED, TO-THE-POINT response.
+Based on the diagnostic analysis, generate a COMPREHENSIVE and DETAILED response.
+The user wants a full explanation, not just a summary.
 
 USER QUERY: {query}
 
@@ -383,47 +386,46 @@ ZONE ANALYSIS:
 HISTORICAL TRENDS:
 {trend_context}
 
-═══════════════════════════════════════════════════════════════
-CRITICAL: RESPONSE STRUCTURE (MUST FOLLOW THIS ORDER)
-═══════════════════════════════════════════════════════════════
-
-**SECTION 1: DIRECT ANSWER (2-3 sentences MAX)**
-- Answer the user's EXACT question immediately
-- No preamble, no explanation - just the answer
-- If it's a yes/no question, start with "Yes" or "No"
-- Include the key data point that supports your answer
-
-**SECTION 2: BRIEF EVIDENCE (1-2 bullets)**
-- Only cite 1-2 most relevant data points
-- Format: "📊 NDVI: 0.45 (below healthy threshold of 0.6)"
-
-**SECTION 3: PRIORITY ACTION (1 main action)**
-- ONE clear, immediate action they should take
-- Include timing: "Do this TODAY/this week/before rain"
-
----
-
-**SECTION 4: AUXILIARY INFORMATION** (only if relevant)
-After the main answer, you MAY add:
-- 🌤️ Weather timing (if relevant to action)
-- 📍 Zone priority (if spatial variation exists)
-- 📈 Trend context (if historical data shows pattern)
-- 💡 Additional tips (max 2 bullets)
-
-═══════════════════════════════════════════════════════════════
-WRONG ❌: "Based on the satellite analysis of your field, I can see that there are several factors to consider. The NDVI values show..."
-RIGHT ✅: "Your crop needs water immediately. NDVI is 0.42, down 15% from last week, indicating water stress."
-═══════════════════════════════════════════════════════════════
-
-FOLLOW-UP AWARENESS:
-- If user asks "what about X" after previous discussion, connect to earlier context
-- Reference previous diagnosis if relevant: "Building on the water stress we discussed..."
-
-ZONE-SPECIFIC (if zone data available):
-- Identify the PRIORITY ZONE needing immediate attention
-- Give zone-specific dosage/quantity if applicable
-
-Keep total response under 150 words for basic farmers, up to 250 for researchers."""
+---------------------------------------------------------------
+CRITICAL: RESPONSE STRUCTURE (MUST FOLLOW THIS EXACT FORMAT)
+---------------------------------------------------------------
+
+**DIAGNOSIS & STATUS**
+* Clearly state the primary issue identified (or confirmation of health).
+* Mention the severity level (Mild/Moderate/Severe) based on the data.
+* State the confidence level in this diagnosis.
+
+**DETAILED REASONING**
+* Explain *WHY* this is the diagnosis, connecting the dots between different data points.
+* Cite specific metrics (NDVI, SMI, NDRE) and explain what they mean in this context.
+* Explicitly mention if the 3-stage analysis (Hypothesis -> Adversary -> Judge) ruled out other causes.
+* Reference historical trends or weather patterns that support this conclusion.
+
+**FUTURE RISKS**
+* Explain what will happen if this issue is ignored for 3-5 days.
+* Mention potential yield impact or long-term damage.
+* Flag any upcoming weather risks (e.g., "Forecast rain might worsen fungal spread").
+
+**RECOMMENDATIONS**
+* **Immediate Action**: What needs to be done TODAY? (be specific: amounts, methods).
+* **Follow-up**: What to check in 3 days.
+* **Long-term**: Preventative measures for next season.
+
+**NEXT STEPS**
+* End with a specific question to keep the conversation going.
+* Examples: 
+  * "Should I help you calculate the fertilizer dosage?"
+  * "Would you like to analyze the historical trends for this field?"
+  * "Shall I monitor this area for you over the next week?"
+
+---------------------------------------------------------------
+GUIDELINES:
+* NO EMOJIS in the output.
+* Use asterisk (*) for bullet points, do NOT use hyphens (-).
+* Bold the section headings.
+* Tone: Professional, authoritative, but helpful (Agro-Expert).
+* Length: Comprehensive (300-500 words is acceptable for Deep Dive).
+"""
 
 
 # =============================================================================
@@ -972,4 +974,99 @@ def format_minimal_diagnosis(result) -> str:
     """Format diagnosis in minimal tokens."""
     if isinstance(result, dict):
         return f"diag:{result.get('final_diagnosis','')} conf:{result.get('final_confidence',0):.2f} cause:{result.get('root_cause','?')}"
-    return str(result)[:100]
+
+# =============================================================================
+# HYBRID ARCHITECTURE PROMPTS
+# =============================================================================
+
+FAST_LANE_PROMPT = """You are Agrow-AI. 
+TASK: Diagnose the crop issue based on the provided context.
+PRIORITY: SPEED & ACCURACY.
+
+CONTEXT:
+{context}
+
+INSTRUCTIONS:
+1. [Hypothesis]: Briefly state what the primary signals (NDVI, NDRE, etc.) suggest.
+2. [Check]: Verify if supporting data (Moisture, Weather) aligns or contradicts.
+3. [Diagnosis]: State the final conclusion.
+4. [Action]: One specific corrective action.
+
+OUTPUT JSON ONLY:
+{{
+    "reasoning_trace": "Hypothesis... Check... Conclusion...",
+    "diagnosis": "Final Diagnosis",
+    "confidence": 0.0-1.0,
+    "action": "Corrective Action"
+}}
+"""
+
+DEEP_DIVE_HYPOTHESIS_PROMPT = """You are Agrow-AI, conducting a DEEP DIVE diagnosis.
+STAGE A: HYPOTHESIS GENERATION
+
+CONTEXT:
+{context}
+
+TASK:
+Identify top 3 possible causes for the observed issues. Do not conclude yet.
+Think broadly (Nutrients, Pests, Water, Soil, Disease).
+
+OUTPUT JSON ONLY:
+{{
+    "hypotheses": [
+        {{"cause": "Cause 1", "likelihood": "High/Med", "reason": "why"}},
+        {{"cause": "Cause 2", "likelihood": "High/Med", "reason": "why"}},
+        {{"cause": "Cause 3", "likelihood": "High/Med", "reason": "why"}}
+    ]
+}}
+"""
+
+DEEP_DIVE_ADVERSARY_PROMPT = """You are Agrow-AI.
+STAGE B: ADVERSARIAL CHECK
+
+HYPOTHESES:
+{hypotheses}
+
+NEW EVIDENCE (Adversarial Data):
+{context}
+
+TASK:
+Actively try to DISPROVE each hypothesis using the new evidence (SAR, Soil, Pests).
+If evidence contradicts a hypothesis, mark it as INVALID.
+
+OUTPUT JSON ONLY:
+{{
+    "analysis": [
+        {{"cause": "Cause 1", "status": "Valid/Invalid", "reason": "Support/Contradiction from new evidence"}},
+        ...
+    ],
+    "surviving_hypothesis": "The strongest remaining cause",
+    "confidence": 0.0-1.0
+}}
+"""
+
+DEEP_DIVE_JUDGE_PROMPT = """You are Agrow-AI.
+STAGE C: FINAL VERDICT
+
+WINNING HYPOTHESIS:
+{hypothesis}
+
+CONSTRAINTS & HISTORY:
+{context}
+
+TASK:
+Provide the final diagnostic report and a detailed action plan.
+Consider farmer constraints (budget, machinery) and historical trends.
+
+OUTPUT JSON ONLY:
+{{
+    "final_diagnosis": "Diagnosis",
+    "root_cause": "Root Cause",
+    "detailed_reasoning": "Explanation of why this is the verdict",
+    "action_plan": {{
+        "immediate": "Action 1",
+        "long_term": "Action 2"
+    }}
+}}
+"""
+

reasoning_engine.py

@@ -19,9 +19,14 @@ from prompts import (
     # Compact prompts for token reduction
     COMPACT_CLAIM_PROMPT, COMPACT_VALIDATE_PROMPT, COMPACT_CONTRADICT_PROMPT,
     COMPACT_CONFIRM_PROMPT, COMPACT_RESPONSE_PROMPT,
-    build_compact_context, get_compact_prompt, format_minimal_diagnosis
+    build_compact_context, get_compact_prompt, format_minimal_diagnosis,
+    # Hybrid Prompts
+    FAST_LANE_PROMPT, DEEP_DIVE_HYPOTHESIS_PROMPT, 
+    DEEP_DIVE_ADVERSARY_PROMPT, DEEP_DIVE_JUDGE_PROMPT
 )
 
+from context_aggregator import ContextAggregator
+
 logger = logging.getLogger("ReasoningEngine")
 
 # Toggle compact prompts to reduce token usage (saves ~50% tokens)
@@ -81,6 +86,7 @@ class ReasoningEngine:
         self.llm = llm_caller
         self.intent_classifier = IntentClassifier()
         self.priority_mapper = PriorityContextMapper()
+        self.aggregator = ContextAggregator()
     
     def process_query(
         self, 
@@ -88,10 +94,7 @@ class ReasoningEngine:
         context: Optional[Dict[str, Any]] = None
     ) -> Tuple[str, Dict[str, Any]]:
         """
-        Process user query through full reasoning pipeline.
-        
-        Returns:
-            (response_text, reasoning_trace)
+        Process user query through Hybrid Architecture (Fast Lane vs Deep Dive).
         """
         logger.info(f"Processing query: {query[:50]}...")
         
@@ -99,16 +102,18 @@ class ReasoningEngine:
         intent = self.intent_classifier.classify(query)
         logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
         
-        # Stage 2: Get prioritized context (NOT all context at once!)
-        staged_context = self.priority_mapper.build_staged_context(
-            intent=intent["primary_intent"],
-            full_context=context or {}
-        )
+        # Stage 2: Route Query
+        mode = self.route_query(query, intent)
+        logger.info(f"Routing mode: {mode}")
         
-        # Stage 3: Multi-stage reasoning
-        reasoning_result = self._reason(query, intent, staged_context)
+        # Stage 3: Execute Logic
+        if mode == "FAST_LANE":
+            reasoning_result = self._execute_fast_lane(query, intent, context or {})
+        else:
+            reasoning_result = self._execute_deep_dive(query, intent, context or {})
         
         # Stage 4: Generate response (pass full context for persona/weather/zone)
+        # Note: Fast Lane already generates action/diagnosis, but we standardize output format
         response = self._generate_response(query, reasoning_result, context)
         
         # Stage 5: Generate followups
@@ -118,9 +123,100 @@ class ReasoningEngine:
         )
         
         # Build complete trace
-        trace = self._build_trace(intent, reasoning_result, staged_context, followups)
+        trace = self._build_trace(intent, reasoning_result, {}, followups)
+        trace["routing_mode"] = mode
         
         return response, trace
+
+    def route_query(self, query: str, intent: Dict) -> str:
+        """Decide between Fast Lane and Deep Dive."""
+        # Intention-based routing
+        fast_intents = ["vegetation_health", "water_stress", "nutrient_status"]
+        if intent["primary_intent"] in fast_intents and intent["confidence"] > 0.7:
+             return "FAST_LANE"
+             
+        # "Why" questions or Comparisons usually need Deep Dive
+        if "compare" in query.lower() or "difference" in query.lower():
+            return "DEEP_DIVE"
+            
+        return "DEEP_DIVE" # Default to robust mode for safety
+        
+    def _execute_fast_lane(self, query: str, intent: Dict, context: Dict) -> ReasoningResult:
+        """Execute 1-Shot Reasoning."""
+        logger.info("Executing FAST LANE (1-Call)...")
+        
+        # Build ultra-compact context
+        compact_ctx = self.aggregator.build_ultra_compact_context(context)
+        
+        prompt = FAST_LANE_PROMPT.format(context=compact_ctx)
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        
+        response = self.llm(full_prompt)
+        
+        output = self._parse_json_safe(response, {
+            "reasoning_trace": "Analysis failed",
+            "diagnosis": "Unknown",
+            "confidence": 0.0,
+            "action": "Consult expert"
+        })
+        
+        # Create Dummy StageResult for compatibility
+        dummy_stage = StageResult("fast_lane", output, [], output.get("confidence", 0.0))
+        
+        return ReasoningResult(
+            claim=dummy_stage, # Fill for struct compatibility
+            validation=dummy_stage,
+            contradiction=dummy_stage,
+            confirmation=dummy_stage,
+            final_diagnosis=output.get("diagnosis", "Unknown"),
+            final_confidence=output.get("confidence", 0.0),
+            causal_chain=output.get("reasoning_trace", ""),
+            root_cause=output.get("diagnosis", "Unknown"),
+            symptoms=[],
+            recommendation=output.get("action", ""),
+            evidence_summary={"method": ["fast_lane_optimization"]}
+        )
+
+    def _execute_deep_dive(self, query: str, intent: Dict, context: Dict) -> ReasoningResult:
+        """Execute 3-Stage Deep Dive."""
+        logger.info("Executing DEEP DIVE (3-Call)...")
+        
+        # 1. Hypothesis Generation
+        ctx_hyp = self.aggregator.build_deep_dive_context(context, "hypothesis")
+        resp_hyp = self.llm(f"{SYSTEM_PROMPT}\n{DEEP_DIVE_HYPOTHESIS_PROMPT.format(context=ctx_hyp)}")
+        out_hyp = self._parse_json_safe(resp_hyp, {"hypotheses": []})
+        
+        # 2. Adversarial Check
+        ctx_adv = self.aggregator.build_deep_dive_context(context, "adversary")
+        hyp_str = json.dumps(out_hyp, indent=2)
+        resp_adv = self.llm(f"{SYSTEM_PROMPT}\n{DEEP_DIVE_ADVERSARY_PROMPT.format(hypotheses=hyp_str, context=ctx_adv)}")
+        out_adv = self._parse_json_safe(resp_adv, {"surviving_hypothesis": "Unknown"})
+        
+        # 3. Final Verdict
+        ctx_judge = self.aggregator.build_deep_dive_context(context, "judge")
+        winner = out_adv.get("surviving_hypothesis", "Unknown")
+        resp_judge = self.llm(f"{SYSTEM_PROMPT}\n{DEEP_DIVE_JUDGE_PROMPT.format(hypothesis=winner, context=ctx_judge)}")
+        out_judge = self._parse_json_safe(resp_judge, {"final_diagnosis": winner, "action_plan": {}})
+        
+        # Map to ReasoningResult
+        # We map stages roughly to Maintain compatibility
+        result_hyp = StageResult("hypothesis", out_hyp, [], 0.0)
+        result_adv = StageResult("adversary", out_adv, [], 0.0)
+        result_judge = StageResult("judge", out_judge, [], 0.0)
+        
+        return ReasoningResult(
+            claim=result_hyp,
+            validation=result_adv,
+            contradiction=result_adv, 
+            confirmation=result_judge,
+            final_diagnosis=out_judge.get("final_diagnosis", "Unknown"),
+            final_confidence=0.9, # Deep dive implies high confidence
+            causal_chain=out_judge.get("detailed_reasoning", ""),
+            root_cause=out_judge.get("root_cause", ""),
+            symptoms=[],
+            recommendation=str(out_judge.get("action_plan", "")),
+            evidence_summary={"method": ["deep_dive_3_stage"]}
+        )
     
     def _reason(
         self,