Update main.py

main.py

@@ -1,12 +1,13 @@
 """
-main.py — Pricelyst Shopping Advisor (Jessica Edition 2026)
+main.py — Pricelyst Shopping Advisor (Jessica Edition 2026 - Upgrade v2.0)
 
 ✅ Flask API
 ✅ Firebase Admin Persistence
-✅ Gemini 2.5 Flash
-✅ "Analyst Engine": Python Math for Baskets & ZESA
-✅ "Creative Engine": 4-Step Hybrid Plans
-✅ Type Safety: Explicit Casting for JSON Serialization (Fixes int64 error)
+✅ Gemini 2.5 Flash (Multimodal)
+✅ "Analyst Engine": Enhanced Basket Math, Category Context, ZESA Logic
+✅ "Jessica Engine": Natural Conversation, Chit-Chat, & Advisory
+✅ "Visual Engine": Lists, Products, & Meal-to-Recipe recognition
+✅ Type Safety: Explicit Casting for JSON Serialization
 
 ENV VARS:
 - GOOGLE_API_KEY=...
@@ -22,8 +23,9 @@ import json
 import time
 import math
 import logging
+import base64
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 import requests
 import pandas as pd
@@ -90,11 +92,11 @@ HTTP_TIMEOUT = 30
 
 # ––––– Static Data (Zim Context) –––––
 
-ZIM_UTILITIES = {
+ZIM_CONTEXT = {
     "fuel_petrol": 1.58,
     "fuel_diesel": 1.65,
     "gas_lpg": 2.00,
-    "bread": 1.00,
+    "bread_avg": 1.00,
     "zesa_step_1": {"limit": 50, "rate": 0.04},
     "zesa_step_2": {"limit": 150, "rate": 0.09},
     "zesa_step_3": {"limit": 9999, "rate": 0.14},
@@ -182,6 +184,7 @@ def fetch_and_flatten_data() -> pd.DataFrame:
 
             prices = p.get("prices") or []
             
+            # If no prices, still index it for context but mark as no offer
             if not prices:
                 rows.append({
                     "product_id": p_id,
@@ -233,7 +236,7 @@ def get_market_index(force_refresh: bool = False) -> pd.DataFrame:
     return _data_cache["df"]
 
 # =========================
-# 2. Analyst Engine (Math Logic)
+# 2. Analyst Engine (Enhanced Math Logic)
 # =========================
 
 def search_products_fuzzy(df: pd.DataFrame, query: str, limit: int = 10) -> pd.DataFrame:
@@ -260,38 +263,60 @@ def search_products_fuzzy(df: pd.DataFrame, query: str, limit: int = 10) -> pd.D
 
     if matches.empty: return matches
 
-    # 3. Sort by Views (Popularity) + Price
+    # 3. Sort by Views + Price
     matches = matches.sort_values(by=['views', 'price'], ascending=[False, True])
     return matches.head(limit)
 
+def get_category_stats(df: pd.DataFrame, category_name: str) -> Dict[str, Any]:
+    """Returns min, max, avg price for a category to determine value."""
+    if df.empty: return {}
+    # Loose matching on category or name
+    cat_df = df[df['category'].str.lower().str.contains(category_name.lower()) & df['is_offer']]
+    if cat_df.empty:
+        # Try name matching if category fails
+        cat_df = df[df['clean_name'].str.contains(category_name.lower()) & df['is_offer']]
+        
+    if cat_df.empty: return {}
+    
+    return {
+        "category": category_name,
+        "min_price": float(cat_df['price'].min()),
+        "max_price": float(cat_df['price'].max()),
+        "avg_price": float(cat_df['price'].mean()),
+        "sample_size": int(len(cat_df))
+    }
+
 def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
     """
-    Determines the best store for a list of items.
-    Explicitly casts int64/float64 to native Python types for JSON safety.
+    Optimizes for:
+    1. Best Single Store (Convenience)
+    2. Split Store (Cheapest possible mix)
     """
     df = get_market_index()
     if df.empty: 
-        logger.warning("Basket Engine: DF is empty.")
         return {"actionable": False, "error": "No data"}
 
-    logger.info(f"Basket Engine: Optimizing for: {item_names}")
-
     found_items = [] 
     missing_global = []
 
-    # 1. Resolve Items to Real Products
+    # 1. Resolve Items
     for item in item_names:
         hits = search_products_fuzzy(df[df['is_offer']==True], item, limit=5)
         if hits.empty:
             missing_global.append(item)
             continue
         
-        # Best match based on popularity
         best_prod = hits.iloc[0]
+        
+        # Get category stats for the first item to help with "is this expensive" logic later
+        cat_stats = get_category_stats(df, str(best_prod['category']))
+        
         found_items.append({
             "query": str(item),
-            "product_id": int(best_prod['product_id']), # Explicit int cast
-            "name": str(best_prod['product_name'])      # Explicit str cast
+            "product_id": int(best_prod['product_id']),
+            "name": str(best_prod['product_name']),
+            "category": str(best_prod['category']),
+            "category_stats": cat_stats
         })
 
     if not found_items:
@@ -299,10 +324,11 @@ def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
             "actionable": True,
             "basket_items": [],
             "global_missing": missing_global,
-            "best_store": None
+            "best_store": None,
+            "split_strategy": None
         }
 
-    # 2. Calculate Retailer Totals
+    # 2. Calculate Retailer Totals (Single Store Strategy)
     target_pids = [x['product_id'] for x in found_items]
     relevant_offers = df[df['product_id'].isin(target_pids) & df['is_offer']]
     
@@ -319,83 +345,122 @@ def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
         
         retailer_stats.append({
             "retailer": str(retailer),
-            "total_price": float(total_price), # Explicit float cast
-            "item_count": int(found_count),    # Explicit int cast
+            "total_price": float(total_price),
+            "item_count": int(found_count),
             "coverage_percent": float((found_count / len(found_items)) * 100),
             "found_items": found_names
         })
 
     retailer_stats.sort(key=lambda x: (-x['coverage_percent'], x['total_price']))
-    best_option = retailer_stats[0] if retailer_stats else None
+    best_single_store = retailer_stats[0] if retailer_stats else None
+
+    # 3. Calculate Split Strategy (Cheapest Global)
+    # For each found item, find the absolute minimum price across all stores
+    split_basket = []
+    split_total = 0.0
+    
+    for item in found_items:
+        # Find offers for this specific product ID
+        p_offers = relevant_offers[relevant_offers['product_id'] == item['product_id']]
+        if not p_offers.empty:
+            best_offer = p_offers.sort_values('price').iloc[0]
+            split_total += best_offer['price']
+            split_basket.append({
+                "item": item['name'],
+                "retailer": str(best_offer['retailer']),
+                "price": float(best_offer['price'])
+            })
+    
+    split_strategy = {
+        "total_price": float(split_total),
+        "breakdown": split_basket,
+        "store_count": len(set(x['retailer'] for x in split_basket))
+    }
 
     return {
         "actionable": True,
         "basket_items": [x['name'] for x in found_items],
         "found_items_details": found_items,
         "global_missing": missing_global,
-        "best_store": best_option,
+        "best_store": best_single_store,
+        "split_strategy": split_strategy,
         "all_stores": retailer_stats[:3]
     }
 
 def calculate_zesa_units(amount_usd: float) -> Dict[str, Any]:
-    remaining = amount_usd / 1.06 
+    """Calculates ZESA units with tiered logic explanation."""
+    remaining = amount_usd / 1.06  # Remove 6% REA Levy approx
     units = 0.0
     breakdown = []
     
-    t1 = ZIM_UTILITIES["zesa_step_1"]
+    t1 = ZIM_CONTEXT["zesa_step_1"]
     cost_t1 = t1["limit"] * t1["rate"]
     
     if remaining > cost_t1:
         units += t1["limit"]
         remaining -= cost_t1
-        breakdown.append(f"First {t1['limit']}u @ ${t1['rate']}")
+        breakdown.append(f"First {t1['limit']} units at cheap rate (${t1['rate']}) ✅")
         
-        t2 = ZIM_UTILITIES["zesa_step_2"]
+        t2 = ZIM_CONTEXT["zesa_step_2"]
         cost_t2 = t2["limit"] * t2["rate"]
         
         if remaining > cost_t2:
             units += t2["limit"]
             remaining -= cost_t2
-            breakdown.append(f"Next {t2['limit']}u @ ${t2['rate']}")
+            breakdown.append(f"Next {t2['limit']} units at standard rate (${t2['rate']}) ⚡")
             
-            t3 = ZIM_UTILITIES["zesa_step_3"]
+            t3 = ZIM_CONTEXT["zesa_step_3"]
             bought = remaining / t3["rate"]
             units += bought
-            breakdown.append(f"Balance -> {bought:.1f}u @ ${t3['rate']}")
+            breakdown.append(f"Remainder bought at high tariff (${t3['rate']}) 💸")
         else:
             bought = remaining / t2["rate"]
             units += bought
-            breakdown.append(f"Balance -> {bought:.1f}u @ ${t2['rate']}")
+            breakdown.append(f"Remainder bought at standard rate (${t2['rate']}) ⚡")
     else:
         bought = remaining / t1["rate"]
         units += bought
-        breakdown.append(f"All {bought:.1f}u @ ${t1['rate']}")
+        breakdown.append(f"All units at cheapest 'Lifeline' rate (${t1['rate']}) 💚")
 
     return {
         "amount_usd": float(amount_usd),
         "est_units_kwh": float(round(units, 1)),
-        "breakdown": breakdown
+        "breakdown": breakdown,
+        "note": "Includes approx 6% REA levy deduction."
     }
 
 # =========================
-# 3. Gemini Helpers
+# 3. Gemini Helpers (Persona & Vision)
 # =========================
 
 def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
-    """Strict Intent Classification."""
+    """
+    Expanded Intent Classification.
+    Detects: CASUAL, SHOPPING_BASKET, UTILITY, STORE_DECISION, TRUST_CHECK
+    """
     if not _gemini_client: return {"actionable": False}
     
     PROMPT = """
     Analyze transcript. Return STRICT JSON.
-    Is user asking for shopping/prices/basket/utility help? (Actionable)
-    Or just saying hello/thanks? (Casual)
+    Classify intent:
+    - CASUAL_CHAT: Greetings, small talk, no shopping data needed.
+    - SHOPPING_BASKET: Looking for prices, creating a list.
+    - UTILITY_CALC: Electricity/ZESA questions.
+    - STORE_DECISION: "Where should I buy?", "Which store is cheapest?".
+    - TRUST_CHECK: "Is this expensive?", "Is this a good deal?".
+    
+    Extract:
+    - items: list of products
+    - utility_amount: number
+    - context: "budget", "speed", "quality" (if mentioned)
     
-    Schema:
+    JSON Schema:
     {
       "actionable": boolean,
-      "intent": "SHOPPING_BASKET" | "UTILITY_CALC" | "PRODUCT_SEARCH" | "CASUAL_CHAT",
-      "items": ["list", "of", "items"],
-      "utility_amount": number
+      "intent": "string",
+      "items": ["string"],
+      "utility_amount": number,
+      "context_tag": "string"
     }
     """
     try:
@@ -409,42 +474,80 @@ def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
         logger.error(f"Intent Detect Error: {e}")
         return {"actionable": False, "intent": "CASUAL_CHAT"}
 
-def gemini_generate_4step_plan(transcript: str, analyst_result: Dict) -> str:
+def gemini_analyze_image(image_b64: str, caption: str = "") -> Dict[str, Any]:
     """
-    The Creative Engine: Generates the 4-Section Plan.
+    Multimodal Image Analysis.
+    Determines if image is a Shopping List, Product, or Meal.
     """
-    if not _gemini_client: return "# Error\nAI Offline."
+    if not _gemini_client: return {"error": "AI Offline"}
+    
+    PROMPT = f"""
+    Analyze this image. Context: {caption}
+    1. Is it a handwritten/printed SHOPPING LIST? -> Extract items.
+    2. Is it a SINGLE PRODUCT? -> Identify the product name.
+    3. Is it a MEAL/DISH? -> Identify the dish and list key ingredients to buy.
+    4. IRRELEVANT? -> Return type "IRRELEVANT".
+
+    Return STRICT JSON:
+    {{
+      "type": "LIST" | "PRODUCT" | "MEAL" | "IRRELEVANT",
+      "items": ["item1", "item2"],
+      "description": "Short description of what is seen"
+    }}
+    """
+    try:
+        image_bytes = base64.b64decode(image_b64)
+        resp = _gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=[
+                types.Part.from_text(PROMPT),
+                types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")
+            ],
+            config=types.GenerateContentConfig(response_mime_type="application/json")
+        )
+        return _safe_json_loads(resp.text, {"type": "IRRELEVANT", "items": []})
+    except Exception as e:
+        logger.error(f"Vision Error: {e}")
+        return {"type": "IRRELEVANT", "items": []}
+
+def gemini_chat_response(transcript: str, intent: Dict, analyst_data: Dict, memory_summary: str = "") -> str:
+    """
+    The Persona Engine (Jessica).
+    Synthesizes Analyst Data + ZESA Context + Memory into a natural response.
+    """
+    if not _gemini_client: return "I'm having trouble connecting to my brain right now."
+
+    # Context Construction
+    context_str = f"USER MEMORY: {memory_summary}\n" if memory_summary else ""
+    context_str += f"ZIMBABWE CONTEXT: Fuel={ZIM_CONTEXT['fuel_petrol']}, ZESA Rate={ZIM_CONTEXT['zesa_step_1']['rate']}\n"
+    
+    if analyst_data:
+        context_str += f"ANALYST DATA: {json.dumps(analyst_data, default=str)}\n"
 
     PROMPT = f"""
-    You are Jessica, Pricelyst's Shopping Advisor.
-    Generate a formatted Markdown Shopping Plan.
-    
-    USER CONTEXT: "{transcript}"
-    
-    ANALYST DATA (REAL PRICES):
-    {json.dumps(analyst_result, indent=2, default=str)}
-
-    REQUIRED SECTIONS (Do not deviate):
-    
-    1. **In Our Catalogue ✅**
-       - List items found in 'found_items_details'.
-       - Show product name, retailer, and exact price from data.
-       
-    2. **Not in Catalogue (Estimates) 😔**
-       - List items from 'global_missing'.
-       - Provide a realistic USD estimate for Zimbabwe.
-       
-    3. **Totals 💰**
-       - Confirmed Total (Catalogue)
-       - Estimated Total (Missing Items)
-       - Grand Total Estimate
-       
-    4. **Ideas & Tips 💡**
-       - Based on the user's event (e.g. Braai, Dinner) or items, suggest 3 creative ideas or forgotten items.
-       - Be fun but practical.
-       
-    Tone: Helpful, Zimbabwean. Use Markdown tables for lists.
+    You are Jessica, Pricelyst's Shopping Advisor (Zimbabwe).
+    Role: Helpful, thrifty, intelligent companion. Not a robot.
+    
+    INPUT: "{transcript}"
+    INTENT: {intent.get('intent')}
+    CONTEXT:
+    {context_str}
+    
+    INSTRUCTIONS:
+    1. **Casual Chat**: If intent is CASUAL, be warm. "Makadii! How can I help you save today?"
+    2. **Shopping Advice**: 
+       - If data exists, guide them. "I found XYZ at Store A for $5."
+       - If 'best_store' exists, recommend it explicitly based on coverage.
+       - If 'split_strategy' saves money (>10%), suggest splitting the shop.
+    3. **Trust & Budget**:
+       - If user asks "Is this expensive?", check 'category_stats' in data.
+       - If price is > avg, say "That's a bit pricey, average is $X."
+    4. **ZESA**: Explain the units naturally using the breakdown provided.
+    
+    TONE: Conversational, Zimbabwean English (use 'USD', maybe 'shame' or 'eish' rarely if bad news, but professional).
+    Do NOT dump JSON. Write a natural message. Use Markdown for lists/prices.
     """
+    
     try:
         resp = _gemini_client.models.generate_content(
             model=GEMINI_MODEL,
@@ -452,7 +555,33 @@ def gemini_generate_4step_plan(transcript: str, analyst_result: Dict) -> str:
         )
         return resp.text
     except Exception as e:
-        logger.error(f"Creative Gen Error: {e}")
+        logger.error(f"Chat Gen Error: {e}")
+        return "I found the data, but I'm struggling to summarize it. Please check the plan below."
+
+def gemini_generate_4step_plan(transcript: str, analyst_result: Dict) -> str:
+    """
+    Generates the Formal Shopping Plan (Markdown).
+    """
+    if not _gemini_client: return "# Error\nAI Offline."
+
+    PROMPT = f"""
+    Generate a formatted Markdown Shopping Plan (Jessica Edition).
+    
+    DATA: {json.dumps(analyst_result, indent=2, default=str)}
+    
+    SECTIONS:
+    1. **In Our Catalogue ✅** (Table: Item | Store | Price)
+    2. **Not in Catalogue 😔** (Estimates)
+    3. **Recommendation 💡**
+       - "Best Single Store" vs "Split & Save" (if split saves money).
+    4. **Budget Tips** (Based on items, e.g., generic brands).
+    
+    Make it look professional yet friendly.
+    """
+    try:
+        resp = _gemini_client.models.generate_content(model=GEMINI_MODEL, contents=PROMPT)
+        return resp.text
+    except Exception as e:
         return "# Error\nCould not generate plan."
 
 # =========================
@@ -465,39 +594,47 @@ def health():
     return jsonify({
         "ok": True,
         "offers_indexed": len(df),
-        "api_source": PRICE_API_BASE
+        "api_source": PRICE_API_BASE,
+        "persona": "Jessica v2.0"
     })
 
 @app.post("/chat")
 def chat():
-    """Text Chat."""
+    """
+    Unified Text Chat Endpoint.
+    Handles Casual, Search, and Advisory intents.
+    """
     body = request.get_json(silent=True) or {}
     msg = body.get("message", "")
     pid = body.get("profile_id")
     
-    if not pid: return jsonify({"ok": False}), 400
+    if not pid: return jsonify({"ok": False, "error": "Missing profile_id"}), 400
     
+    # 1. Memory Lookup
+    memory_summary = ""
+    if db:
+        prof = db.collection("pricelyst_profiles").document(pid).get()
+        if prof.exists: memory_summary = prof.to_dict().get("memory_summary", "")
+
+    # 2. Intent Detection
     intent_data = gemini_detect_intent(msg)
+    intent_type = intent_data.get("intent", "CASUAL_CHAT")
+    items = intent_data.get("items", [])
+    
     analyst_data = {}
     
-    if intent_data.get("actionable"):
-        if intent_data["intent"] == "SHOPPING_BASKET" and intent_data.get("items"):
-            analyst_data = calculate_basket_optimization(intent_data["items"])
-        elif intent_data["intent"] == "UTILITY_CALC":
-            analyst_data = calculate_zesa_units(intent_data.get("utility_amount", 20))
-        elif intent_data["intent"] == "PRODUCT_SEARCH" and intent_data.get("items"):
-            analyst_data = calculate_basket_optimization(intent_data["items"])
-
-    reply = "I'm processing that for you."
-    if analyst_data:
-        try:
-            resp = _gemini_client.models.generate_content(
-                model=GEMINI_MODEL,
-                contents=f"Summarize this shopping data for chat:\n{json.dumps(analyst_data, default=str)}"
-            )
-            reply = resp.text
-        except: pass
-
+    # 3. Data Processing (The Analyst)
+    if intent_type in ["SHOPPING_BASKET", "STORE_DECISION", "TRUST_CHECK"] and items:
+        analyst_data = calculate_basket_optimization(items)
+        
+    elif intent_type == "UTILITY_CALC":
+        amount = intent_data.get("utility_amount", 20)
+        analyst_data = calculate_zesa_units(amount)
+        
+    # 4. Response Generation (The Persona)
+    reply = gemini_chat_response(msg, intent_data, analyst_data, memory_summary)
+    
+    # 5. Async Logging
     if db:
         db.collection("pricelyst_profiles").document(pid).collection("chat_logs").add({
             "message": msg,
@@ -506,12 +643,62 @@ def chat():
             "ts": datetime.now(timezone.utc).isoformat()
         })
 
-    return jsonify({"ok": True, "data": {"message": reply, "analyst": analyst_data}})
+    return jsonify({
+        "ok": True, 
+        "data": {
+            "message": reply, 
+            "analyst_debug": analyst_data if items else None
+        }
+    })
+
+@app.post("/api/analyze-image")
+def analyze_image():
+    """
+    New Endpoint: Handles Image -> List/Product/Meal -> Shopping Data
+    """
+    body = request.get_json(silent=True) or {}
+    image_b64 = body.get("image_data") # Base64 string
+    caption = body.get("caption", "")
+    pid = body.get("profile_id")
+    
+    if not image_b64 or not pid: return jsonify({"ok": False}), 400
+    
+    # 1. Vision Analysis
+    vision_result = gemini_analyze_image(image_b64, caption)
+    img_type = vision_result.get("type", "IRRELEVANT")
+    items = vision_result.get("items", [])
+    
+    response_text = ""
+    analyst_data = {}
+    
+    # 2. Logic Branching
+    if img_type == "IRRELEVANT":
+        response_text = "I see the image, but I can't find any shopping items or meals in it. Try a receipt, a product, or a plate of food!"
+        
+    elif items:
+        # Run the Analyst Engine on the extracted items
+        analyst_data = calculate_basket_optimization(items)
+        
+        # Craft a specific prompt for image results
+        intent_sim = {"intent": "SHOPPING_BASKET"}
+        response_text = gemini_chat_response(
+            f"User uploaded image of {img_type}: {vision_result.get('description')}. Items found: {items}", 
+            intent_sim, 
+            analyst_data
+        )
+    
+    return jsonify({
+        "ok": True,
+        "image_type": img_type,
+        "items_identified": items,
+        "message": response_text,
+        "analyst_data": analyst_data
+    })
 
 @app.post("/api/call-briefing")
 def call_briefing():
     """
-    Injects Memory + Top 60 Mini-Catalogue.
+    Injects Memory + Context for Voice Bot.
     """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
@@ -531,19 +718,16 @@ def call_briefing():
     if username and username != prof.get("username"):
         if db: db.collection("pricelyst_profiles").document(pid).set({"username": username}, merge=True)
 
-    # --- Mini-Catalogue Generation ---
+    # Mini-Catalogue (Top 60 items for context)
     df = get_market_index()
     catalogue_str = ""
     if not df.empty:
-        # Top 60 Popular items with Price
         top = df[df['is_offer']].sort_values('views', ascending=False).drop_duplicates('product_name').head(60)
-        lines = []
-        for _, r in top.iterrows():
-            lines.append(f"{r['product_name']} (~${r['price']:.2f})")
+        lines = [f"{r['product_name']} (~${r['price']:.2f})" for _, r in top.iterrows()]
         catalogue_str = ", ".join(lines)
 
     kpi_snapshot = {
-        "market_rates": ZIM_UTILITIES,
+        "market_rates": ZIM_CONTEXT,
         "popular_products": catalogue_str
     }
     
@@ -557,6 +741,7 @@ def call_briefing():
 def log_call_usage():
     """
     Post-Call Orchestrator.
+    Generates Plans & Updates Memory.
     """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
@@ -564,43 +749,38 @@ def log_call_usage():
     
     if not pid: return jsonify({"ok": False}), 400
     
-    logger.info(f"Log Call: Processing {pid}. Transcript Len: {len(transcript)}")
-
+    # 1. Update Memory
     if len(transcript) > 20 and db:
         try:
             curr_mem = db.collection("pricelyst_profiles").document(pid).get().to_dict().get("memory_summary", "")
-            mem_prompt = f"Update user memory with details from transcript:\nOLD: {curr_mem}\nTRANSCRIPT: {transcript}"
+            mem_prompt = f"Update user memory (budget, family size, favorite stores) based on this transcript:\nOLD: {curr_mem}\nTRANSCRIPT: {transcript}"
             mem_resp = _gemini_client.models.generate_content(model=GEMINI_MODEL, contents=mem_prompt)
             db.collection("pricelyst_profiles").document(pid).set({"memory_summary": mem_resp.text}, merge=True)
         except Exception as e:
             logger.error(f"Memory Update Error: {e}")
 
+    # 2. Plan Generation
     intent_data = gemini_detect_intent(transcript)
-    logger.info(f"Intent: {intent_data.get('intent')}")
-    
     plan_data = {}
     
-    if intent_data.get("actionable"):
+    if intent_data.get("actionable") and intent_data.get("items"):
+        analyst_result = calculate_basket_optimization(intent_data["items"])
         
-        if intent_data.get("items"):
-            analyst_result = calculate_basket_optimization(intent_data["items"])
+        if analyst_result.get("actionable"):
+            md_content = gemini_generate_4step_plan(transcript, analyst_result)
             
-            if analyst_result.get("actionable"):
-                md_content = gemini_generate_4step_plan(transcript, analyst_result)
-                
-                plan_data = {
-                    "is_actionable": True,
-                    "title": f"Shopping Plan ({datetime.now().strftime('%d %b')})",
-                    "markdown_content": md_content,
-                    "items": intent_data["items"],
-                    "created_at": datetime.now(timezone.utc).isoformat()
-                }
-                
-                if db:
-                    doc_ref = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document()
-                    plan_data["id"] = doc_ref.id
-                    doc_ref.set(plan_data)
-                    logger.info(f"Plan Saved: {doc_ref.id}")
+            plan_data = {
+                "is_actionable": True,
+                "title": f"Shopping Plan ({datetime.now().strftime('%d %b')})",
+                "markdown_content": md_content,
+                "items": intent_data["items"],
+                "created_at": datetime.now(timezone.utc).isoformat()
+            }
+            
+            if db:
+                doc_ref = db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").document()
+                plan_data["id"] = doc_ref.id
+                doc_ref.set(plan_data)
 
     if db:
         db.collection("pricelyst_profiles").document(pid).collection("call_logs").add({
@@ -615,8 +795,6 @@ def log_call_usage():
         "shopping_plan": plan_data if plan_data.get("is_actionable") else None
     })
 
-# ––––– CRUD –––––
-
 @app.get("/api/shopping-plans")
 def list_plans():
     pid = request.args.get("profile_id")