Update main.py

main.py

@@ -1,12 +1,13 @@
 """
-main.py — Pricelyst Shopping Advisor (Analyst Edition)
+main.py — Pricelyst Shopping Advisor (Analyst Edition - Full Context)
 
 ✅ Flask API
 ✅ Firebase Admin Persistence
 ✅ Gemini via google-genai SDK (Robust)
 ✅ "Analyst Engine": Python Math for Baskets, ZESA, & Fuel
 ✅ Ground Truth Data: Uses /api/v1/product-listing
-✅ Real-Time Basket Optimization
+✅ Jessica Context: Injects Top 60 Real Products into Voice Agent
+✅ Intent Detection: Strict Casual vs Actionable separation
 
 ENV VARS:
 - GOOGLE_API_KEY=...
@@ -23,7 +24,7 @@ import time
 import math
 import logging
 from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 import requests
 import pandas as pd
@@ -91,15 +92,14 @@ HTTP_TIMEOUT = 30
 # ––––– Static Data (Zim Context) –––––
 
 ZIM_UTILITIES = {
-    "fuel_petrol": 1.58,  # USD per Litre
-    "fuel_diesel": 1.65,  # USD per Litre
-    "gas_lpg": 2.00,      # USD per kg
-    "bread": 1.00,        # USD fixed
-    # ZESA Estimates (Simplified Stepped Tariff)
-    "zesa_step_1": {"limit": 50, "rate": 0.04},   # First 50 units (Life line)
-    "zesa_step_2": {"limit": 150, "rate": 0.09},  # Next 150
-    "zesa_step_3": {"limit": 9999, "rate": 0.14}, # Balance
-    "zesa_levy": 0.06 # 6% REA levy approx
+    "fuel_petrol": 1.58,
+    "fuel_diesel": 1.65,
+    "gas_lpg": 2.00,
+    "bread": 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},
+    "zesa_levy": 0.06
 }
 
 # ––––– Cache –––––
@@ -107,7 +107,7 @@ ZIM_UTILITIES = {
 PRODUCT_CACHE_TTL = 60 * 20 # 20 mins
 _data_cache: Dict[str, Any] = {
     "ts": 0,
-    "df": pd.DataFrame(), # Columns: [id, name, clean_name, brand, category, retailer, price, views, image]
+    "df": pd.DataFrame(),
     "raw_count": 0
 }
 
@@ -119,7 +119,6 @@ CORS(app)
 # =========================
 
 def _norm(s: Any) -> str:
-    """Normalize string for fuzzy search."""
     if not s: return ""
     return str(s).strip().lower()
 
@@ -129,17 +128,26 @@ def _coerce_price(v: Any) -> float:
     except:
         return 0.0
 
+def _safe_json_loads(s: str, fallback: Any):
+    try:
+        if "```json" in s:
+            s = s.split("```json")[1].split("```")[0]
+        elif "```" in s:
+            s = s.split("```")[0]
+        return json.loads(s)
+    except Exception as e:
+        logger.error(f"JSON Parse Error: {e}")
+        return fallback
+
 def fetch_and_flatten_data() -> pd.DataFrame:
-    """
-    Fetches from /api/v1/product-listing and flattens into an analytical DF.
-    Each row represents a single 'Offer' (Product X at Retailer Y).
-    """
+    """Fetches from /api/v1/product-listing and flattens into an analytical DF."""
     all_products = []
     page = 1
     
+    logger.info("ETL: Starting fetch from /api/v1/product-listing")
+    
     while True:
         try:
-            # New Endpoint Structure
             url = f"{PRICE_API_BASE}/api/v1/product-listing"
             r = requests.get(url, params={"page": page, "perPage": 50}, timeout=HTTP_TIMEOUT)
             r.raise_for_status()
@@ -165,8 +173,6 @@ def fetch_and_flatten_data() -> pd.DataFrame:
             p_name = p.get("name") or "Unknown"
             clean_name = _norm(p_name)
             
-            # Category & Brand extraction
-            # Based on user JSON: 'category' is an object inside product
             cat_obj = p.get("category") or {}
             cat_name = cat_obj.get("name") or "General"
             
@@ -176,10 +182,8 @@ def fetch_and_flatten_data() -> pd.DataFrame:
             views = int(p.get("view_count") or 0)
             image = p.get("thumbnail") or p.get("image")
 
-            # Prices array
             prices = p.get("prices") or []
             
-            # If no prices, we still index product for "Knowledge" but with price=0
             if not prices:
                 rows.append({
                     "product_id": p_id,
@@ -217,10 +221,10 @@ def fetch_and_flatten_data() -> pd.DataFrame:
             continue
 
     df = pd.DataFrame(rows)
+    logger.info(f"ETL: Flattened into {len(df)} rows.")
     return df
 
 def get_market_index(force_refresh: bool = False) -> pd.DataFrame:
-    """Singleton access to the Dataframe."""
     global _data_cache
     if force_refresh or _data_cache["df"].empty or (time.time() - _data_cache["ts"] > PRODUCT_CACHE_TTL):
         logger.info("ETL: Refreshing Market Index...")
@@ -228,7 +232,6 @@ def get_market_index(force_refresh: bool = False) -> pd.DataFrame:
         _data_cache["df"] = df
         _data_cache["ts"] = time.time()
         _data_cache["raw_count"] = len(df)
-        logger.info(f"ETL: Loaded {len(df)} market offers.")
     return _data_cache["df"]
 
 # =========================
@@ -236,57 +239,58 @@ def get_market_index(force_refresh: bool = False) -> pd.DataFrame:
 # =========================
 
 def search_products_fuzzy(df: pd.DataFrame, query: str, limit: int = 10) -> pd.DataFrame:
-    """Finds products matching query (Name, Brand, or Category)."""
     if df.empty or not query: return df
     
     q_norm = _norm(query)
-    q_tokens = set(q_norm.split())
     
-    # Quick filter: String contains
+    # 1. Broad Filter (Contains)
     mask_name = df['clean_name'].str.contains(q_norm, regex=False)
-    mask_brand = df['brand'].str.lower().str.contains(q_norm, regex=False)
-    mask_cat = df['category'].str.lower().str.contains(q_norm, regex=False)
-    
-    matches = df[mask_name | mask_brand | mask_cat].copy()
-    
-    # Simple Scoring
-    def scorer(row):
-        score = 0
-        if q_norm in row['clean_name']: score += 10
-        if q_norm == row['clean_name']: score += 20
-        # Popularity boost
-        score += math.log(row['views'] + 1) * 0.5
-        return score
-
-    if not matches.empty:
-        matches['score'] = matches.apply(scorer, axis=1)
-        return matches.sort_values('score', ascending=False).head(limit)
-    
-    return matches
+    matches = df[mask_name].copy()
+    
+    # 2. If no exact contains, try token overlap
+    if matches.empty:
+        q_tokens = set(q_norm.split())
+        def token_score(text):
+            if not isinstance(text, str): return 0
+            text_tokens = set(text.split())
+            if not text_tokens: return 0
+            intersection = q_tokens.intersection(text_tokens)
+            return len(intersection)
+        
+        df_scored = df.copy()
+        df_scored['score'] = df_scored['clean_name'].apply(token_score)
+        matches = df_scored[df_scored['score'] > 0]
+
+    if matches.empty:
+        return matches
+
+    # 3. Rank by Popularity (Views) + Price
+    matches = matches.sort_values(by=['views', 'price'], ascending=[False, True])
+    return matches.head(limit)
 
 def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
     """
-    Killer Question: 'Where should I buy this list?'
-    Returns: Best Store, Missing Items, Total Cost.
+    Determines the best store for a list of items.
     """
     df = get_market_index()
-    if df.empty: return {"error": "No data"}
+    if df.empty: 
+        logger.warning("Basket Engine: DF is empty.")
+        return {"actionable": False, "error": "No data"}
+
+    logger.info(f"Basket Engine: Optimizing for {len(item_names)} items: {item_names}")
 
-    basket_results = []
+    found_items = [] 
     missing_global = []
 
     # 1. Resolve Items to Real Products
-    found_items = [] # list of (item_query, product_id, product_name)
-    
     for item in item_names:
-        # Find best matching product (using popularity tie-breaker)
         hits = search_products_fuzzy(df[df['is_offer']==True], item, limit=5)
         if hits.empty:
             missing_global.append(item)
             continue
         
-        # Pick the most popular product that matches this query
-        best_prod = hits.sort_values('views', ascending=False).iloc[0]
+        # Pick best match (First one is sorted by Views/Price)
+        best_prod = hits.iloc[0]
         found_items.append({
             "query": item,
             "product_id": best_prod['product_id'],
@@ -294,16 +298,13 @@ def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
         })
 
     if not found_items:
-        return {"actionable": False, "reason": "No items found in database."}
+        logger.info("Basket Engine: No items matched in DB.")
+        return {"actionable": False, "missing": missing_global}
 
     # 2. Calculate Totals Per Retailer
-    # We only care about retailers that stock these products
     target_pids = [x['product_id'] for x in found_items]
-    
-    # Filter DF to only relevant products
     relevant_offers = df[df['product_id'].isin(target_pids) & df['is_offer']]
     
-    # Group by Retailer
     retailer_stats = []
     all_retailers = relevant_offers['retailer'].unique()
     
@@ -313,9 +314,8 @@ def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
         found_count = len(r_df)
         total_price = r_df['price'].sum()
         
-        # Identify what this retailer has vs misses
+        # Identify misses
         retailer_pids = r_df['product_id'].tolist()
-        missing_in_store = [x['name'] for x in found_items if x['product_id'] not in retailer_pids]
         found_names = [x['name'] for x in found_items if x['product_id'] in retailer_pids]
         
         retailer_stats.append({
@@ -323,191 +323,123 @@ def calculate_basket_optimization(item_names: List[str]) -> Dict[str, Any]:
             "total_price": float(total_price),
             "item_count": found_count,
             "coverage_percent": (found_count / len(found_items)) * 100,
-            "missing": missing_in_store,
             "found_items": found_names
         })
 
-    # 3. Sort by: Coverage (Desc), then Price (Asc)
+    # 3. Sort: Coverage Desc, Price Asc
     retailer_stats.sort(key=lambda x: (-x['coverage_percent'], x['total_price']))
     
-    best_option = retailer_stats[0] if retailer_stats else None
-    
+    if not retailer_stats:
+        return {"actionable": False}
+
+    best_option = retailer_stats[0]
+    logger.info(f"Basket Engine: Best Store = {best_option['retailer']} (${best_option['total_price']})")
+
     return {
         "actionable": True,
         "basket_items": [x['name'] for x in found_items],
         "global_missing": missing_global,
         "best_store": best_option,
-        "all_stores": retailer_stats[:3] # Return top 3 for comparison
+        "all_stores": retailer_stats[:3]
     }
 
 def calculate_zesa_units(amount_usd: float) -> Dict[str, Any]:
-    """
-    Killer Question: 'How much ZESA do I get for $20?'
-    Uses a simplified tiered logic (Approximation of ZESA tariff).
-    """
     remaining = amount_usd / 1.06 # Remove 6% levy approx
     units = 0.0
     breakdown = []
     
-    # Tier 1: First 50 units (Cheap)
     t1 = ZIM_UTILITIES["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']} units @ ${t1['rate']}")
+        breakdown.append(f"First {t1['limit']}u @ ${t1['rate']}")
         
-        # Tier 2: Next 150
         t2 = ZIM_UTILITIES["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']} units @ ${t2['rate']}")
+            breakdown.append(f"Next {t2['limit']}u @ ${t2['rate']}")
             
-            # Tier 3: Balance (Expensive)
             t3 = ZIM_UTILITIES["zesa_step_3"]
             bought = remaining / t3["rate"]
             units += bought
-            breakdown.append(f"Remaining ${(remaining + cost_t1 + cost_t2):.2f} bought {bought:.1f} units @ ${t3['rate']}")
+            breakdown.append(f"Balance ${(remaining + cost_t1 + cost_t2):.2f} -> {bought:.1f}u @ ${t3['rate']}")
         else:
             bought = remaining / t2["rate"]
             units += bought
-            breakdown.append(f"Balance bought {bought:.1f} units @ ${t2['rate']}")
+            breakdown.append(f"Balance -> {bought:.1f}u @ ${t2['rate']}")
     else:
         bought = remaining / t1["rate"]
         units += bought
-        breakdown.append(f"All {bought:.1f} units @ ${t1['rate']}")
+        breakdown.append(f"All {bought:.1f}u @ ${t1['rate']}")
 
     return {
         "amount_usd": amount_usd,
         "est_units_kwh": round(units, 1),
-        "breakdown": breakdown,
-        "note": "Estimates include ~6% REA levy. Actual units depend on your last purchase date."
-    }
-
-def get_product_intelligence(query: str) -> Dict[str, Any]:
-    """
-    Killer Question: 'Is this price reasonable?' / 'Most Popular?'
-    """
-    df = get_market_index()
-    hits = search_products_fuzzy(df[df['is_offer']], query, limit=10)
-    
-    if hits.empty: return {"found": False}
-    
-    # Group by product ID to find the specific product stats
-    best_match_pid = hits.iloc[0]['product_id']
-    product_rows = df[(df['product_id'] == best_match_pid) & (df['is_offer'])]
-    
-    if product_rows.empty: return {"found": False}
-    
-    min_price = product_rows['price'].min()
-    max_price = product_rows['price'].max()
-    avg_price = product_rows['price'].mean()
-    cheapest_row = product_rows.loc[product_rows['price'].idxmin()]
-    
-    return {
-        "found": True,
-        "name": cheapest_row['product_name'],
-        "brand": cheapest_row['brand'],
-        "category": cheapest_row['category'],
-        "view_count": int(cheapest_row['views']),
-        "price_stats": {
-            "min": float(min_price),
-            "max": float(max_price),
-            "avg": float(avg_price),
-            "spread": float(max_price - min_price)
-        },
-        "best_deal": {
-            "retailer": cheapest_row['retailer'],
-            "price": float(min_price)
-        },
-        "all_offers": product_rows[['retailer', 'price']].to_dict('records')
+        "breakdown": breakdown
     }
 
 # =========================
-# 3. Gemini Context Layer
+# 3. Gemini Helpers (Strict)
 # =========================
 
-def generate_analyst_response(transcript: str) -> Dict[str, Any]:
+def gemini_detect_intent(transcript: str) -> Dict[str, Any]:
     """
-    1. Detect Intent (Basket? Utility? Single Item?)
-    2. Run Python Analyst Function.
-    3. Generate Text Response.
+    Classifies if the conversation needs an Analyst action.
     """
-    if not _gemini_client: return {"message": "AI Brain offline."}
-
-    # Step A: Intent Classification
-    INTENT_PROMPT = """
-    Analyze the user input. Return JSON.
-    Intents:
-    - "BASKET": User has a list of items (e.g. "Oil, bread and rice").
-    - "UTILITY": User asks about ZESA, Fuel, Gas prices or units.
-    - "PRODUCT_INTEL": User asks for "Cheapest X", "Price of X", "Popular X".
-    - "CHAT": General conversation.
-    
-    Output: { "intent": "...", "items": ["..."], "utility_type": "zesa/fuel/gas", "amount": number }
+    if not _gemini_client: return {"actionable": False}
+    
+    PROMPT = """
+    Analyze this transcript. Return STRICT JSON.
+    Is the user asking for shopping help (prices, basket, store advice, ZESA/Fuel)?
+    
+    Output Schema:
+    {
+      "actionable": boolean,
+      "intent": "SHOPPING_BASKET" | "UTILITY_CALC" | "PRODUCT_SEARCH" | "CASUAL_CHAT",
+      "items": ["item1", "item2"] (if applicable),
+      "utility_amount": number (if applicable for ZESA/Fuel)
+    }
     """
     
     try:
         resp = _gemini_client.models.generate_content(
             model=GEMINI_MODEL,
-            contents=INTENT_PROMPT + "\nInput: " + transcript,
+            contents=PROMPT + "\nTranscript: " + transcript,
             config=types.GenerateContentConfig(response_mime_type="application/json")
         )
-        parsed = json.loads(resp.text)
-    except:
-        parsed = {"intent": "CHAT"}
+        return _safe_json_loads(resp.text, {"actionable": False, "intent": "CASUAL_CHAT"})
+    except Exception as e:
+        logger.error(f"Intent Detect Error: {e}")
+        return {"actionable": False, "intent": "CASUAL_CHAT"}
 
-    intent = parsed.get("intent")
-    data_context = {}
+def gemini_chat_response(transcript: str, analyst_data: Dict) -> str:
+    if not _gemini_client: return "System offline."
     
-    # Step B: Execute Analyst Logic
-    if intent == "BASKET":
-        items = parsed.get("items", [])
-        if items:
-            data_context = calculate_basket_optimization(items)
-            
-    elif intent == "UTILITY":
-        u_type = parsed.get("utility_type", "")
-        amt = parsed.get("amount") or 0
-        if "zesa" in u_type and amt > 0:
-            data_context = calculate_zesa_units(float(amt))
-        elif "fuel" in u_type or "petrol" in u_type:
-            rate = ZIM_UTILITIES["fuel_petrol"]
-            data_context = {"type": "Petrol", "rate": rate, "units": amt / rate}
-            
-    elif intent == "PRODUCT_INTEL":
-        items = parsed.get("items", [])
-        if items:
-            data_context = get_product_intelligence(items[0])
-
-    # Step C: Synthesis (Speak based on Data)
-    SYNTHESIS_PROMPT = f"""
-    You are Jessica, the Pricelyst Analyst.
-    User Input: "{transcript}"
+    PROMPT = f"""
+    You are Jessica, Pricelyst Analyst.
+    User asked: "{transcript}"
     
-    ANALYST DATA (Strictly use this):
-    {json.dumps(data_context, indent=2)}
+    DATA (Use this strictly):
+    {json.dumps(analyst_data, indent=2)}
     
-    If 'actionable' is false or data is empty, suggest what data you need.
-    If basket data exists, summarize: "The best store for your basket is [Retailer] at $[Total]."
-    If ZESA data exists, be precise about units.
-    Keep it helpful and Zimbabwean.
+    If 'actionable' is true, summarize the Best Store and Total Cost.
+    If ZESA data is present, give the units estimate.
+    Keep it short, helpful, and Zimbabwean.
     """
     
-    final_resp = _gemini_client.models.generate_content(
-        model=GEMINI_MODEL,
-        contents=SYNTHESIS_PROMPT
-    )
-    
-    return {
-        "intent": intent,
-        "analyst_data": data_context,
-        "message": final_resp.text
-    }
+    try:
+        resp = _gemini_client.models.generate_content(
+            model=GEMINI_MODEL,
+            contents=PROMPT
+        )
+        return resp.text
+    except:
+        return "I have the data but couldn't summarize it."
 
 # =========================
 # 4. Endpoints
@@ -531,23 +463,38 @@ def chat():
     
     if not pid: return jsonify({"ok": False}), 400
     
-    response_data = generate_analyst_response(msg)
+    # 1. Detect Intent
+    intent_data = gemini_detect_intent(msg)
+    analyst_data = {}
     
-    # Log interaction
+    # 2. Run Analyst (if actionable)
+    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"):
+            # Reuse basket logic for single item search to get best store
+            analyst_data = calculate_basket_optimization(intent_data["items"])
+
+    # 3. Generate Reply
+    reply = gemini_chat_response(msg, analyst_data)
+    
+    # Log
     if db:
         db.collection("pricelyst_profiles").document(pid).collection("chat_logs").add({
             "message": msg,
-            "response": response_data,
+            "response_text": reply,
+            "intent": intent_data,
             "ts": datetime.now(timezone.utc).isoformat()
         })
 
-    return jsonify({"ok": True, "data": response_data})
+    return jsonify({"ok": True, "data": {"message": reply, "analyst": analyst_data}})
 
 @app.post("/api/call-briefing")
 def call_briefing():
     """
-    Context for ElevenLabs. 
-    Crucially: We DO NOT send the whole database. We send Memory + Utilities.
+    Injects Memory + Top Products Catalogue for the Voice Agent.
     """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
@@ -564,11 +511,25 @@ def call_briefing():
         else:
             ref.set({"created_at": datetime.now(timezone.utc).isoformat()})
     
-    # Simple snapshot
+    if username and username != prof.get("username"):
+        if db: db.collection("pricelyst_profiles").document(pid).set({"username": username}, merge=True)
+
+    # --- Generate Mini-Catalogue (Top 60 popular items) ---
+    df = get_market_index()
+    top_products_str = ""
+    if not df.empty:
+        # Sort by views desc, take top 60 unique product names
+        top_offers = df[df['is_offer']].sort_values('views', ascending=False).drop_duplicates('product_name').head(60)
+        # Format: "Name ($AvgPrice)"
+        items_list = []
+        for _, r in top_offers.iterrows():
+            items_list.append(f"{r['product_name']} (~${r['price']:.2f})")
+        top_products_str = ", ".join(items_list)
+
+    # Payload for ElevenLabs (Data Variables Only)
     kpi_snapshot = {
-        "username": username or prof.get("username", "Friend"),
-        "utilities": ZIM_UTILITIES,
-        "instructions": "You are Jessica. If asked for prices, say you can check the live system. For ZESA/Fuel, use the 'utilities' variable."
+        "market_rates": ZIM_UTILITIES,
+        "popular_products_catalogue": top_products_str
     }
     
     return jsonify({
@@ -581,8 +542,9 @@ def call_briefing():
 def log_call_usage():
     """
     Post-Call Processor.
-    1. Update Memory.
-    2. Generate Grounded Shopping Plan.
+    1. Intent Check (Strict).
+    2. Analyst Optimization.
+    3. Plan Gen & Persistence.
     """
     body = request.get_json(silent=True) or {}
     pid = body.get("profile_id")
@@ -590,66 +552,71 @@ def log_call_usage():
     
     if not pid: return jsonify({"ok": False}), 400
     
-    logger.info(f"Processing Call {pid}. Len: {len(transcript)}")
-    
-    # 1. Update Memory (Gemini)
+    logger.info(f"Log Call: Processing {pid}. Transcript Len: {len(transcript)}")
+
+    # 1. Update Memory (Async-like)
     if len(transcript) > 20 and db:
         try:
-            prof_ref = db.collection("pricelyst_profiles").document(pid)
-            curr_mem = prof_ref.get().to_dict().get("memory_summary", "")
-            
-            mem_prompt = f"Update this memory summary with new details from the transcript (names, preferences, budget):\nOLD: {curr_mem}\nTRANSCRIPT: {transcript}"
-            
-            resp = _gemini_client.models.generate_content(
-                model=GEMINI_MODEL,
-                contents=mem_prompt
-            )
-            prof_ref.set({"memory_summary": resp.text}, merge=True)
+            curr_mem = db.collection("pricelyst_profiles").document(pid).get().to_dict().get("memory_summary", "")
+            mem_prompt = f"Update user memory (concise) with new details:\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 Failed: {e}")
 
-    # 2. Generate Plan (Analyst Engine Integration)
-    # We re-run the Analyst logic specifically for the plan
-    analyst_result = generate_analyst_response(transcript)
+    # 2. Intent Detection (The Gatekeeper)
+    intent_data = gemini_detect_intent(transcript)
+    logger.info(f"Log Call: Intent detected: {intent_data.get('intent')}")
+    
     plan_data = {}
     
-    if analyst_result.get("intent") == "BASKET" and analyst_result.get("analyst_data", {}).get("actionable"):
-        # We have a valid basket!
-        data = analyst_result["analyst_data"]
-        best = data["best_store"]
-        
-        # Markdown Generation
-        md = f"# Your Shopping Plan\n\n"
-        md += f"**Best Store:** {best['retailer']}\n"
-        md += f"**Total Cost:** ${best['total_price']:.2f} (for {best['item_count']} items)\n\n"
+    # 3. Actionable Logic
+    if intent_data.get("actionable"):
         
-        md += "| Item | Found? |\n|---|---|\n"
-        for item in data['basket_items']:
-            found = "✅" if item in best['found_items'] else "❌"
-            md += f"| {item} | {found} |\n"
+        # Handle Shopping List
+        if intent_data.get("items"):
+            analyst_result = calculate_basket_optimization(intent_data["items"])
             
-        if data['global_missing']:
-            md += f"\n**Missing from Market:** {', '.join(data['global_missing'])}"
-            
-        plan_data = {
-            "is_actionable": True,
-            "title": f"Plan: {best['retailer']} (${best['total_price']:.2f})",
-            "markdown_content": md,
-            "items": data['basket_items']
-        }
-        
-        # Save Plan
-        if db:
-            db.collection("pricelyst_profiles").document(pid).collection("shopping_plans").add({
-                **plan_data,
-                "created_at": datetime.now(timezone.utc).isoformat()
-            })
-
-    # 3. Log Call
+            if analyst_result.get("actionable"):
+                best = analyst_result["best_store"]
+                
+                # Markdown Generation
+                md = f"# Shopping Plan\n\n"
+                md += f"**Recommended Store:** {best['retailer']}\n"
+                md += f"**Estimated Total:** ${best['total_price']:.2f}\n\n"
+                
+                md += "## Your Basket\n\n"
+                md += "| Item | Found? |\n|---|---|\n"
+                for it in analyst_result["basket_items"]:
+                    status = "✅ In Stock" if it in best["found_items"] else "❌ Not Found"
+                    md += f"| {it} | {status} |\n"
+                
+                if analyst_result["global_missing"]:
+                    md += "\n### Missing Items (Estimate Required)\n"
+                    for m in analyst_result["global_missing"]:
+                        md += f"- {m}\n"
+                
+                plan_data = {
+                    "is_actionable": True,
+                    "title": f"Plan: {best['retailer']} (${best['total_price']:.2f})",
+                    "markdown_content": md,
+                    "items": intent_data["items"],
+                    "created_at": datetime.now(timezone.utc).isoformat()
+                }
+                
+                # Persist Plan
+                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"Log Call: Plan Saved {doc_ref.id}")
+
+    # 4. Log Call
     if db:
         db.collection("pricelyst_profiles").document(pid).collection("call_logs").add({
             "transcript": transcript,
-            "analyst_result": analyst_result,
+            "intent_data": intent_data,
+            "plan_generated": bool(plan_data),
             "ts": datetime.now(timezone.utc).isoformat()
         })
 
@@ -658,7 +625,7 @@ def log_call_usage():
         "shopping_plan": plan_data if plan_data.get("is_actionable") else None
     })
 
-# ––––– Shopping Plan CRUD (Standard) –––––
+# ––––– CRUD: Shopping Plans –––––
 
 @app.get("/api/shopping-plans")
 def list_plans():
@@ -669,8 +636,8 @@ def list_plans():
                  .order_by("created_at", direction=firestore.Query.DESCENDING).limit(10).stream()
         plans = [{"id": d.id, **d.to_dict()} for d in docs]
         return jsonify({"ok": True, "plans": plans})
-    except Exception as e:
-        return jsonify({"ok": False, "error": str(e)}), 500
+    except:
+        return jsonify({"ok": False}), 500
 
 @app.delete("/api/shopping-plans/<plan_id>")
 def delete_plan(plan_id):