Update app.py

app.py

@@ -1,59 +1,114 @@
-# server_gemini_seg.py
+# server_suggestions.py
+"""
+Suggestion-focused server for outfit recommendations.
+
+Endpoints:
+ - POST /suggest_candidates  -> produce candidate outfits (Step 1)
+ - POST /refine_candidates   -> refine candidates with constraints (Step 2)
+ - POST /finalize_suggestion -> finalize a candidate and return the suggestion (Step 3)
+
+This server intentionally omits image detection and upload endpoints — it expects
+the client to send pre-extracted wardrobe item summaries (id, analysis, title, thumbnail_url...).
+
+Features:
+ - Optional Gemini integration (GEMINI_API_KEY)
+ - Optional Firestore integration (FIREBASE_ADMIN_JSON) for:
+     * reading/writing user summary at users/{uid}
+     * reading recent suggestions in collection 'suggestions' for the past week
+   All Firestore operations are wrapped with graceful failures so the service still works
+   when Firestore isn't configured.
+"""
 
 import os
-import io
 import json
-import base64
 import logging
 import uuid
 import time
 import difflib
-from typing import List, Dict, Any, Tuple, Optional
+from typing import List, Dict, Any, Set, Optional
 
 from flask import Flask, request, jsonify
 from flask_cors import CORS
-from PIL import Image, ImageOps
-import numpy as np
-import cv2
 
-# genai client
-from google import genai
-from google.genai import types
+# optional genai client
+try:
+    from google import genai
+    from google.genai import types
+    GENAI_AVAILABLE = True
+except Exception:
+    genai = None
+    types = None
+    GENAI_AVAILABLE = False
 
-# Firebase Admin (in-memory JSON init)
+# optional firebase admin (Firestore)
 try:
     import firebase_admin
-    from firebase_admin import credentials as fb_credentials, storage as fb_storage
-
-    FIREBASE_ADMIN_AVAILABLE = True
+    from firebase_admin import credentials as fb_credentials
+    from firebase_admin import firestore as fb_firestore_module
+    FIREBASE_AVAILABLE = True
 except Exception:
     firebase_admin = None
     fb_credentials = None
-    fb_storage = None
-    FIREBASE_ADMIN_AVAILABLE = False
+    fb_firestore_module = None
+    FIREBASE_AVAILABLE = False
 
 logging.basicConfig(level=logging.INFO)
-log = logging.getLogger("wardrobe-server")
-
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "")
-if not GEMINI_API_KEY:
-    log.warning("GEMINI_API_KEY not set — gemini calls will fail (but fallback still works).")
+log = logging.getLogger("suggestion-server")
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "").strip()
+if GEMINI_API_KEY and GENAI_AVAILABLE:
+    client = genai.Client(api_key=GEMINI_API_KEY)
+    log.info("Gemini client configured.")
+else:
+    client = None
+    if GEMINI_API_KEY and not GENAI_AVAILABLE:
+        log.warning("GEMINI_API_KEY provided but genai SDK not installed. Gemini disabled.")
+    else:
+        log.info("GEMINI_API_KEY not provided; using fallback heuristics.")
+
+# Firestore service account JSON in env variable (stringified JSON)
+FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
 
-client = genai.Client(api_key=GEMINI_API_KEY) if GEMINI_API_KEY else None
+# Firestore runtime state
+_firestore_client = None
+_firebase_app = None
 
-# Firebase config (read service account JSON from env)
-FIREBASE_ADMIN_JSON = os.getenv("FIREBASE_ADMIN_JSON", "").strip()
-FIREBASE_STORAGE_BUCKET = os.getenv("FIREBASE_STORAGE_BUCKET", "").strip()  # optional override
 
-if FIREBASE_ADMIN_JSON and not FIREBASE_ADMIN_AVAILABLE:
-    log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK is not installed. Install firebase-admin.")
+def init_firestore_if_needed():
+    """
+    Initialize firebase admin and Firestore client if FIREBASE_ADMIN_JSON is set.
+    Returns Firestore client or None on failure/unconfigured.
+    """
+    global _firestore_client, _firebase_app
+    if _firestore_client is not None:
+        return _firestore_client
+    if not FIREBASE_ADMIN_JSON:
+        log.info("No FIREBASE_ADMIN_JSON env var set; Firestore not initialized.")
+        return None
+    if not FIREBASE_AVAILABLE:
+        log.warning("FIREBASE_ADMIN_JSON provided but firebase-admin SDK not installed; skip Firestore init.")
+        return None
+    try:
+        sa_obj = json.loads(FIREBASE_ADMIN_JSON)
+    except Exception as e:
+        log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
+        return None
+    try:
+        cred = fb_credentials.Certificate(sa_obj)
+        # If app already exists, avoid re-initializing
+        try:
+            _firebase_app = firebase_admin.get_app()
+        except Exception:
+            _firebase_app = firebase_admin.initialize_app(cred)
+        _firestore_client = fb_firestore_module.client()
+        log.info("Initialized Firestore client.")
+        return _firestore_client
+    except Exception as e:
+        log.exception("Failed to initialize Firestore: %s", e)
+        return None
 
-app = Flask(__name__)
-CORS(app)
 
-# ---------- Categories mapping (map model 'type' to frontend categories) ----------
-# NOTE: If frontend has a definitive categories array, replace this list with that array.
-# We use difflib.get_close_matches to pick the closest category from CATEGORIES.
+# ---------- Category mapping (kept small and deterministic) ----------
 CATEGORIES = [
     "top",
     "shirt",
@@ -82,466 +137,400 @@ CATEGORIES = [
 
 
 def map_type_to_category(item_type: str) -> str:
-    """Map a model-produced type string to the closest category from CATEGORIES.
-    Falls back to 'unknown' if no reasonable match is found.
-    """
     if not item_type:
         return "others"
     t = item_type.strip().lower()
-    # direct hit
     if t in CATEGORIES:
         return t
-    # try splitting or common plural handling
     t_clean = t.rstrip("s")
     if t_clean in CATEGORIES:
         return t_clean
-    # fuzzy match
     matches = difflib.get_close_matches(t, CATEGORIES, n=1, cutoff=0.6)
     if matches:
         return matches[0]
-    # attempt to match by token intersection
     for token in t.replace("_", " ").split():
         if token in CATEGORIES:
             return token
     return "others"
 
 
-# ---------- Firebase init helpers ----------
+# ---------- Lightweight helpers for brands and matching ----------
 
-_firebase_app = None
+def _safe_item_brand(itm: Dict[str, Any]) -> str:
+    analysis = itm.get("analysis") or {}
+    brand = analysis.get("brand") if isinstance(analysis, dict) else None
+    if not brand:
+        brand = itm.get("brand") or ""
+    return str(brand).strip()
 
 
-def init_firebase_admin_if_needed():
-    global _firebase_app
-    if _firebase_app is not None:
-        return _firebase_app
-    if not FIREBASE_ADMIN_JSON:
-        log.info("No FIREBASE_ADMIN_JSON env var set; skipping Firebase admin init.")
-        return None
-    if not FIREBASE_ADMIN_AVAILABLE:
-        raise RuntimeError("firebase-admin not installed (pip install firebase-admin)")
-    try:
-        sa_obj = json.loads(FIREBASE_ADMIN_JSON)
-    except Exception as e:
-        log.exception("Failed parsing FIREBASE_ADMIN_JSON: %s", e)
-        raise
-    bucket_name = FIREBASE_STORAGE_BUCKET or (sa_obj.get("project_id") and f"{sa_obj.get('project_id')}.appspot.com")
-    if not bucket_name:
-        raise RuntimeError(
-            "Could not determine storage bucket. Set FIREBASE_STORAGE_BUCKET or include project_id in service account JSON."
-        )
-    try:
-        cred = fb_credentials.Certificate(sa_obj)
-        _firebase_app = firebase_admin.initialize_app(cred, {"storageBucket": bucket_name})
-        log.info("Initialized firebase admin with bucket: %s", bucket_name)
-        return _firebase_app
-    except Exception as e:
-        log.exception("Failed to initialize firebase admin: %s", e)
-        raise
+def _item_matches_brand_constraints(itm: Dict[str, Any], require_brands: Set[str], reject_brands: Set[str]) -> bool:
+    brand = _safe_item_brand(itm).lower()
+    if require_brands and brand and brand not in require_brands:
+        return False
+    if reject_brands and brand and brand in reject_brands:
+        return False
+    return True
+
 
+# ---------- Naive candidate generator (fallback) ----------
 
-def upload_b64_to_firebase(base64_str: str, path: str, content_type="image/jpeg", metadata: dict = None) -> str:
-    """Upload base64 string to Firebase Storage at `path`. Optionally attach metadata dict (custom metadata).
-    Returns a public URL when possible, otherwise returns gs:///.
+def naive_generate_candidates(wardrobe_items: List[Dict[str, Any]],
+                              user_inputs: Dict[str, Any],
+                              user_profile: Dict[str, Any],
+                              past_week_items: List[Dict[str, Any]],
+                              max_candidates: int = 6) -> List[Dict[str, Any]]:
     """
-    if not FIREBASE_ADMIN_JSON:
-        raise RuntimeError("FIREBASE_ADMIN_JSON not set")
-    init_firebase_admin_if_needed()
-    if not FIREBASE_ADMIN_AVAILABLE:
-        raise RuntimeError("firebase-admin not available")
+    Simple combinatorial generator that groups items by category and composes outfits.
+    Returns a list of candidate dicts: { id, items: [...], score, reason, notes }.
+    """
+    grouped = {}
+    for itm in wardrobe_items:
+        title = (itm.get("title") or (itm.get("analysis") or {}).get("type") or itm.get("label") or "")
+        cat = map_type_to_category(title)
+        grouped.setdefault(cat, []).append(itm)
+
+    def pick(cat, n=3):
+        arr = grouped.get(cat, [])[:]
+        arr.sort(key=lambda x: float(x.get("confidence", 0.5)), reverse=True)
+        return arr[:n]
+
+    tops = pick("top", 5) + pick("shirt", 3) + pick("tshirt", 3)
+    bottoms = pick("pants", 4) + pick("jeans", 3) + pick("skirt", 2)
+    outer = pick("jacket", 3) + pick("coat", 2)
+    shoes = pick("shoe", 4) + pick("sneaker", 3) + pick("boot", 2) + pick("heels", 2)
+    dresses = grouped.get("dress", [])[:4]
+    accessories = pick("accessory", 3) + pick("bag", 2)
+
+    seeds = dresses + tops
+    if not seeds:
+        seeds = wardrobe_items[:6]
+
+    past_ids = {x.get("id") for x in (past_week_items or []) if x.get("id")}
+    candidates = []
+    used = set()
+
+    for seed in seeds:
+        for b in (bottoms[:3] or [None]):
+            for sh in (shoes[:3] or [None]):
+                items = [seed]
+                if b and b.get("id") != seed.get("id"):
+                    items.append(b)
+                if sh and sh.get("id") not in {seed.get("id'), b.get('id') if b else None}:
+                    items.append(sh)
+                ids = tuple(sorted([str(x.get("id")) for x in items if x.get("id")]))
+                if ids in used:
+                    continue
+                used.add(ids)
+                score = sum(float(x.get("confidence", 0.5)) for x in items) / max(1, len(items))
+                if any(x.get("id") in past_ids for x in items if x.get("id")):
+                    score -= 0.15
+                # add small randomization
+                score = max(0, min(1, score + (0.05 * (0.5 - (hash(ids) % 100) / 100.0))))
+                candidate = {
+                    "id": str(uuid.uuid4()),
+                    "items": [{"id": x.get("id"), "label": x.get("label"), "title": x.get("title"), "thumbnail_url": x.get("thumbnail_url"), "analysis": x.get("analysis", {})} for x in items],
+                    "score": round(float(score), 3),
+                    "reason": "Auto combo",
+                    "notes": "",
+                }
+                candidates.append(candidate)
+                if len(candidates) >= max_candidates:
+                    break
+            if len(candidates) >= max_candidates:
+                break
+        if len(candidates) >= max_candidates:
+            break
+
+    candidates.sort(key=lambda c: c.get("score", 0), reverse=True)
+    return candidates
 
-    raw = base64_str
-    if raw.startswith("data:"):
-        raw = raw.split(",", 1)[1]
-    raw = raw.replace("\n", "").replace("\r", "")
-    data = base64.b64decode(raw)
 
+# ---------- Gemini-backed candidate generator (optional) ----------
+
+def generate_candidates_with_gemini(wardrobe_items: List[Dict[str, Any]],
+                                    user_inputs: Dict[str, Any],
+                                    user_profile: Dict[str, Any],
+                                    past_week_items: List[Dict[str, Any]],
+                                    max_candidates: int = 6) -> List[Dict[str, Any]]:
+    if not client:
+        log.info("Gemini not configured; using naive generator.")
+        return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
+
+    # create concise wardrobe entries for the prompt
+    summarized = []
+    for it in wardrobe_items:
+        a = it.get("analysis") or {}
+        summarized.append({
+            "id": it.get("id"),
+            "type": a.get("type") or it.get("title") or it.get("label") or "",
+            "summary": (a.get("summary") or "")[:180],
+            "brand": (a.get("brand") or "")[:80],
+            "tags": a.get("tags") or [],
+            "thumbnail_url": it.get("thumbnail_url") or ""
+        })
+
+    prompt = (
+        "You are a stylist assistant. Given a user's WARDROBE array (id,type,summary,brand,tags),\n"
+        "and USER_INPUT object containing moods, appearances, events, activity, preferred/excluded colors, keyBrands, etc.,\n"
+        "and a list PAST_WEEK of recently used item ids, produce up to {max} candidate outfits.\n\n"
+        "Return only valid JSON: {\"candidates\": [ {\"id\": \"..\", \"item_ids\": [..], \"score\": 0-1, \"notes\": \"one-line explanation\", \"short_reason\": \"phrase\"}, ... ]}\n\n"
+        "Prefer diverse, practical combinations and avoid reusing PAST_WEEK item ids when possible.\n\n"
+        "WARDROBE = {wardrobe}\nUSER_INPUT = {u}\nPAST_WEEK = {p}\n".format(max=max_candidates, wardrobe=json.dumps(summarized), u=json.dumps(user_inputs), p=json.dumps([p.get("id") for p in (past_week_items or [])]))
+    )
+
+    contents = [types.Content(role="user", parts=[types.Part.from_text(text=prompt)])]
+    schema = {
+        "type": "object",
+        "properties": {
+            "candidates": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "id": {"type": "string"},
+                        "item_ids": {"type": "array", "items": {"type": "string"}},
+                        "score": {"type": "number"},
+                        "notes": {"type": "string"},
+                        "short_reason": {"type": "string"},
+                    },
+                    "required": ["id", "item_ids"],
+                },
+            }
+        },
+        "required": ["candidates"],
+    }
+    cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
     try:
-        bucket = fb_storage.bucket()
-        blob = bucket.blob(path)
-        blob.upload_from_string(data, content_type=content_type)
-        if metadata:
-            try:
-                blob.metadata = {k: (json.dumps(v) if not isinstance(v, str) else v) for k, v in metadata.items()}
-                blob.patch()
-            except Exception as me:
-                log.warning("Failed to patch metadata for %s: %s", path, me)
-        try:
-            blob.make_public()
-            return blob.public_url
-        except Exception as e:
-            log.warning("Could not make blob public: %s", e)
-            return f"gs://{bucket.name}/{path}"
+        resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)
+        raw = resp.text or ""
+        parsed = json.loads(raw)
+        id_map = {str(it.get("id")): it for it in wardrobe_items}
+        out = []
+        for c in parsed.get("candidates", [])[:max_candidates]:
+            items = []
+            for iid in c.get("item_ids", []):
+                itm = id_map.get(str(iid))
+                if itm:
+                    items.append({"id": itm.get("id"), "label": itm.get("label"), "title": itm.get("title"), "thumbnail_url": itm.get("thumbnail_url"), "analysis": itm.get("analysis", {})})
+            out.append({
+                "id": c.get("id") or str(uuid.uuid4()),
+                "items": items,
+                "score": float(c.get("score", 0.5)),
+                "reason": c.get("short_reason") or "",
+                "notes": (c.get("notes") or "")[:300],
+            })
+        if not out:
+            log.warning("Gemini returned no candidates; falling back.")
+            return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
+        out.sort(key=lambda x: x.get("score", 0), reverse=True)
+        return out[:max_candidates]
     except Exception as e:
-        log.exception("Firebase upload error for path %s: %s", path, e)
-        raise
+        log.exception("Gemini candidate generation failed: %s", e)
+        return naive_generate_candidates(wardrobe_items, user_inputs, user_profile, past_week_items, max_candidates)
 
 
-# ---------- Image helpers (with EXIF transpose) ----------
+# ---------- Refinement logic (Step 2) ----------
 
+def refine_candidates_with_constraints(candidates: List[Dict[str, Any]],
+                                       wardrobe_items: List[Dict[str, Any]],
+                                       constraints: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Apply brand constraints, schedule constraints and attach item metadata.
+    Returns dict with keys: refined, rerun_required (bool), rerun_hint, removed (list).
+    """
+    require_brands = set([b.lower() for b in (constraints.get("require_brands") or []) if b])
+    reject_brands = set([b.lower() for b in (constraints.get("reject_brands") or []) if b])
+    past_ids = set([x.get("id") for x in (constraints.get("past_week_items") or []) if x.get("id")])
+    allow_rerun = bool(constraints.get("allow_rerun", False))
+
+    id_map = {str(it.get("id")): it for it in wardrobe_items}
+    refined = []
+    removed = []
+
+    for cand in candidates:
+        items = cand.get("items") or []
+        # If items are lightweight (only id), resolve them
+        resolved_items = []
+        for i in items:
+            iid = str(i.get("id"))
+            full = id_map.get(iid)
+            if full:
+                resolved_items.append(full)
+            else:
+                resolved_items.append(i)
+        # Check brand constraints
+        if require_brands:
+            if not any((_safe_item_brand(it).lower() in require_brands) for it in resolved_items):
+                removed.append({"id": cand.get("id"), "reason": "missing required brand"})
+                continue
+        if reject_brands:
+            if any((_safe_item_brand(it).lower() in reject_brands) for it in resolved_items):
+                removed.append({"id": cand.get("id"), "reason": "contains rejected brand"})
+                continue
+        # Check schedule conflict
+        if past_ids and any((it.get("id") in past_ids) for it in resolved_items):
+            if not allow_rerun:
+                removed.append({"id": cand.get("id"), "reason": "uses recent items"})
+                continue
+            else:
+                cand["_conflict_with_schedule"] = True
 
-def read_image_bytes(file_storage) -> Tuple[np.ndarray, int, int, bytes]:
-    """Read bytes, apply EXIF orientation, return BGR numpy, width, height and raw bytes."""
-    data = file_storage.read()
-    img = Image.open(io.BytesIO(data))
-    try:
-        img = ImageOps.exif_transpose(img)
-    except Exception:
-        pass
-    img = img.convert("RGB")
-    w, h = img.size
-    arr = np.array(img)[:, :, ::-1]  # RGB -> BGR
-    return arr, w, h, data
-
-
-def crop_and_b64(bgr_img: np.ndarray, x: int, y: int, w: int, h: int, max_side=512) -> str:
-    h_img, w_img = bgr_img.shape[:2]
-    x = max(0, int(x))
-    y = max(0, int(y))
-    x2 = min(w_img, int(x + w))
-    y2 = min(h_img, int(y + h))
-    crop = bgr_img[y:y2, x:x2]
-    if crop.size == 0:
-        return ""
-    max_dim = max(crop.shape[0], crop.shape[1])
-    if max_dim > max_side:
-        scale = max_side / max_dim
-        crop = cv2.resize(crop, (int(crop.shape[1] * scale), int(crop.shape[0] * scale)), interpolation=cv2.INTER_AREA)
-    _, jpeg = cv2.imencode(".jpg", crop, [int(cv2.IMWRITE_JPEG_QUALITY), 82])
-    return base64.b64encode(jpeg.tobytes()).decode("ascii")
-
-
-def fallback_contour_crops(bgr_img, max_items=8) -> List[Dict[str, Any]]:
-    gray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY)
-    blur = cv2.GaussianBlur(gray, (7, 7), 0)
-    thresh = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY_INV, 15, 6)
-    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (9, 9))
-    closed = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)
-    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-    h_img, w_img = bgr_img.shape[:2]
-    min_area = (w_img * h_img) * 0.005
-    items = []
-    for cnt in sorted(contours, key=cv2.contourArea, reverse=True):
-        if len(items) >= max_items:
-            break
-        area = cv2.contourArea(cnt)
-        if area < min_area:
-            continue
-        x, y, w, h = cv2.boundingRect(cnt)
-        pad_x, pad_y = int(w * 0.07), int(h * 0.07)
-        x = max(0, x - pad_x)
-        y = max(0, y - pad_y)
-        w = min(w_img - x, w + pad_x * 2)
-        h = min(h_img - y, h + pad_y * 2)
-        b64 = crop_and_b64(bgr_img, x, y, w, h)
-        if not b64:
-            continue
-        items.append(
+        # attach metadata
+        cand["items"] = [
             {
-                "id": str(uuid.uuid4()),
-                "label": "unknown",
-                "confidence": min(0.95, max(0.25, area / (w_img * h_img))),
-                "bbox": {"x": x, "y": y, "w": w, "h": h},
-                "thumbnail_b64": b64,
-                "source": "fallback",
+                "id": it.get("id"),
+                "label": it.get("label"),
+                "title": it.get("title"),
+                "thumbnail_url": it.get("thumbnail_url"),
+                "analysis": it.get("analysis", {}),
+                "confidence": it.get("confidence", 0.5),
             }
-        )
-    if not items:
-        h_half, w_half = h_img // 2, w_img // 2
-        rects = [(0, 0, w_half, h_half), (w_half, 0, w_half, h_half), (0, h_half, w_half, h_half), (w_half, h_half, w_half, h_half)]
-        for r in rects:
-            b64 = crop_and_b64(bgr_img, r[0], r[1], r[2], r[3])
-            if b64:
-                items.append(
-                    {
-                        "id": str(uuid.uuid4()),
-                        "label": "unknown",
-                        "confidence": 0.3,
-                        "bbox": {"x": r[0], "y": r[1], "w": r[2], "h": r[3]},
-                        "thumbnail_b64": b64,
-                        "source": "fallback-grid",
-                    }
-                )
-    return items
-
-
-# ---------- AI analysis helper ----------
-
-
-def analyze_crop_with_gemini(jpeg_b64: str) -> Dict[str, Any]:
-    """Run Gemini on the cropped image bytes to extract:
-    type (one-word category like 'shoe', 'jacket', 'dress'),
-    summary (single-line description), brand (string or empty), tags (array of short descriptors)
-    Returns dict, falls back to empty/defaults on error or missing key.
-    """
+            for it in resolved_items
+        ]
+        refined.append(cand)
+
+    if not refined:
+        hint = "All candidates filtered out. Consider loosening brand/schedule constraints or allow rerun."
+        return {"refined": [], "rerun_required": True, "rerun_hint": hint, "removed": removed}
+    refined.sort(key=lambda c: c.get("score", 0), reverse=True)
+    return {"refined": refined, "rerun_required": False, "rerun_hint": "", "removed": removed}
+
+
+# ---------- Final note generation (Step 3) ----------
+
+def finalize_suggestion_note_with_gemini(candidate: Dict[str, Any], user_inputs: Dict[str, Any], user_profile: Dict[str, Any]) -> str:
     if not client:
-        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
+        moods = ", ".join(user_inputs.get("moods", [])[:2])
+        events = ", ".join(user_inputs.get("events", [])[:1])
+        return f"Because you chose {moods or 'your mood'} for {events or 'your event'} — practical and stylish."
     try:
-        # prepare prompt
         prompt = (
-            "You are an assistant that identifies clothing item characteristics from an image. "
-            "Return only a JSON object with keys: type (single word like 'shoe','top','jacket'), "
-            "summary (a single short sentence, one line), brand (brand name if visible else empty string), "
-            "tags (an array of short single-word tags describing visible attributes, e.g. ['striped','leather','white']). "
-            "Keep values short and concise."
+            "You are a concise stylist. Given CANDIDATE_ITEMS (list of short item descriptions) and USER_INPUT, "
+            "write a single short friendly sentence (<=18 words) explaining why this outfit was chosen. Return plain text.\n\n"
         )
-
-        contents = [types.Content(role="user", parts=[types.Part.from_text(text=prompt)])]
-
-        # attach the image bytes
-        image_bytes = base64.b64decode(jpeg_b64)
-        contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg")]))
-
-        schema = {
-            "type": "object",
-            "properties": {
-                "type": {"type": "string"},
-                "summary": {"type": "string"},
-                "brand": {"type": "string"},
-                "tags": {"type": "array", "items": {"type": "string"}},
-            },
-            "required": ["type", "summary"],
-        }
-        cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
-
-        # call model (use the same model family you used before)
-        resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg)
-        text = resp.text or ""
-        parsed = {}
-        try:
-            parsed = json.loads(text)
-            # coerce expected shapes
-            parsed["type"] = str(parsed.get("type", "")).strip()
-            parsed["summary"] = str(parsed.get("summary", "")).strip()
-            parsed["brand"] = str(parsed.get("brand", "")).strip()
-            tags = parsed.get("tags", [])
-            if not isinstance(tags, list):
-                tags = []
-            parsed["tags"] = [str(t).strip() for t in tags if str(t).strip()]
-        except Exception as e:
-            log.warning("Failed parsing Gemini analysis JSON: %s — raw: %s", e, (text[:300] if text else ""))
-            parsed = {"type": "unknown", "summary": "", "brand": "", "tags": []}
-        return {
-            "type": parsed.get("type", "unknown") or "unknown",
-            "summary": parsed.get("summary", "") or "",
-            "brand": parsed.get("brand", "") or "",
-            "tags": parsed.get("tags", []) or [],
-        }
+        candidate_items = []
+        for it in candidate.get("items", []):
+            desc = (it.get("analysis") or {}).get("summary") or it.get("label") or it.get("title") or ""
+            brand = (it.get("analysis") or {}).get("brand") or ""
+            candidate_items.append({"id": it.get("id"), "desc": desc[:160], "brand": brand[:60]})
+        contents = [
+            types.Content(role="user", parts=[types.Part.from_text(text=prompt)]),
+            types.Content(role="user", parts=[types.Part.from_text(text="CANDIDATE_ITEMS: " + json.dumps(candidate_items))]),
+            types.Content(role="user", parts=[types.Part.from_text(text="USER_INPUT: " + json.dumps(user_inputs or {}))]),
+            types.Content(role="user", parts=[types.Part.from_text(text="Return only a single short sentence.")]),
+        ]
+        resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents)
+        text = (resp.text or "").strip()
+        return text.splitlines()[0] if text else "A curated outfit chosen for your preferences."
     except Exception as e:
-        log.exception("analyze_crop_with_gemini failure: %s", e)
-        return {"type": "unknown", "summary": "", "brand": "", "tags": []}
-
+        log.exception("Gemini finalize note failed: %s", e)
+        moods = ", ".join(user_inputs.get("moods", [])[:2])
+        events = ", ".join(user_inputs.get("events", [])[:1])
+        return f"Because you chose {moods or 'your mood'}, for {events or 'your event'} — practical and stylish."
 
-# ---------- Main / processing ----------
 
+# ---------- Firestore helpers for user summary & recent suggestions (graceful) ----------
 
-@app.route("/process", methods=["POST"])
-def process_image():
-    if "photo" not in request.files:
-        return jsonify({"error": "missing photo"}), 400
-    file = request.files["photo"]
-
-    uid = (request.form.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
+def get_or_create_user_summary(uid: str, fallback_from_inputs: Dict[str, Any]) -> str:
+    """
+    Attempts to read users/{uid} document's 'summary' field.
+    If missing or Firestore not configured, creates a heuristic summary and writes it back (if possible).
+    Returns the summary string.
+    """
+    fs = init_firestore_if_needed()
+    gen_summary = None
     try:
-        bgr_img, img_w, img_h, raw_bytes = read_image_bytes(file)
+        if not fs:
+            # Firestore not available
+            log.info("Firestore not available. Building local user summary.")
+            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
+            return gen_summary
+        doc_ref = fs.collection("users").document(uid)
+        doc = doc_ref.get()
+        if doc.exists:
+            data = doc.to_dict() or {}
+            summary = data.get("summary")
+            if summary:
+                return summary
+            # if doc exists but no summary, create one
+            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
+            try:
+                doc_ref.set({"summary": gen_summary, "updatedAt": int(time.time())}, merge=True)
+                log.info("Wrote generated summary into users/%s", uid)
+            except Exception as e:
+                log.warning("Failed to write generated summary to Firestore: %s", e)
+            return gen_summary
+        else:
+            # doc doesn't exist -> create with heuristic summary
+            gen_summary = _heuristic_summary_from_inputs(fallback_from_inputs)
+            try:
+                doc_ref.set({"summary": gen_summary, "createdAt": int(time.time())})
+                log.info("Created users/%s with summary", uid)
+            except Exception as e:
+                log.warning("Failed to create user doc in Firestore: %s", e)
+            return gen_summary
     except Exception as e:
-        log.error("invalid image: %s", e)
-        return jsonify({"error": "invalid image"}), 400
-
-    session_id = str(uuid.uuid4())
-
-    # Detection prompt (same as before)
-    user_prompt = (
-        "You are an assistant that extracts clothing detections from a single image. "
-        "Return a JSON object with a single key 'items' which is an array. Each item must have: "
-        "label (string, short like 'top','skirt','sneakers'), "
-        "bbox with normalized coordinates between 0 and 1: {x, y, w, h} where x,y are top-left relative to width/height, "
-        "confidence (0-1). Example output: {\"items\":[{\"label\":\"top\",\"bbox\":{\"x\":0.1,\"y\":0.2,\"w\":0.3,\"h\":0.4},\"confidence\":0.95}]} "
-        "Output ONLY valid JSON. If you cannot detect any clothing confidently, return {\"items\":[]}."
-    )
+        log.exception("Error fetching/creating user summary: %s", e)
+        return gen_summary or _heuristic_summary_from_inputs(fallback_from_inputs)
 
-    try:
-        contents = [types.Content(role="user", parts=[types.Part.from_text(text=user_prompt)])]
-        contents.append(types.Content(role="user", parts=[types.Part.from_bytes(data=raw_bytes, mime_type="image/jpeg")]))
 
-        schema = {
-            "type": "object",
-            "properties": {
-                "items": {
-                    "type": "array",
-                    "items": {
-                        "type": "object",
-                        "properties": {
-                            "label": {"type": "string"},
-                            "bbox": {
-                                "type": "object",
-                                "properties": {
-                                    "x": {"type": "number"},
-                                    "y": {"type": "number"},
-                                    "w": {"type": "number"},
-                                    "h": {"type": "number"},
-                                },
-                                "required": ["x", "y", "w", "h"],
-                            },
-                            "confidence": {"type": "number"},
-                        },
-                        "required": ["label", "bbox", "confidence"],
-                    },
-                }
-            },
-            "required": ["items"],
-        }
-
-        cfg = types.GenerateContentConfig(response_mime_type="application/json", response_schema=schema)
+def fetch_recent_suggestions(uid: str, days: int = 7) -> List[Dict[str, Any]]:
+    """
+    Attempts to fetch recent suggestions from collection 'suggestions' for uid within `days`.
+    Returns a list of item dicts used recently (flattened items).
+    If Firestore not available or query fails, returns empty list.
+    """
+    fs = init_firestore_if_needed()
+    if not fs:
+        return []
+    try:
+        cutoff = int(time.time()) - days * 86400
+        q = fs.collection("suggestions").where("uid", "==", uid).where("createdAtTs", ">=", cutoff).limit(50)
+        docs = q.get()
+        items = []
+        for d in docs:
+            dd = d.to_dict() or {}
+            for it in dd.get("items", []) or []:
+                items.append({"id": it.get("id"), "label": it.get("label")})
+        return items
+    except Exception as e:
+        log.warning("Failed to fetch recent suggestions: %s", e)
+        return []
 
-        log.info("Calling Gemini model for detection (gemini-2.5-flash-lite)...")
-        model_resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents=contents, config=cfg) if client else None
-        raw_text = (model_resp.text or "") if model_resp else ""
-        log.info("Gemini raw response length: %d", len(raw_text))
 
-        parsed = None
-        try:
-            parsed = json.loads(raw_text) if raw_text else None
-        except Exception as e:
-            log.warning("Could not parse Gemini JSON: %s", e)
-            parsed = None
-
-        items_out: List[Dict[str, Any]] = []
-        if parsed and isinstance(parsed.get("items"), list) and len(parsed["items"]) > 0:
-            for it in parsed["items"]:
-                try:
-                    label = str(it.get("label", "unknown"))[:48]
-                    bbox = it.get("bbox", {})
-                    nx = float(bbox.get("x", 0))
-                    ny = float(bbox.get("y", 0))
-                    nw = float(bbox.get("w", 0))
-                    nh = float(bbox.get("h", 0))
-                    nx = max(0.0, min(1.0, nx))
-                    ny = max(0.0, min(1.0, ny))
-                    nw = max(0.0, min(1.0, nw))
-                    nh = max(0.0, min(1.0, nh))
-                    px = int(nx * img_w)
-                    py = int(ny * img_h)
-                    pw = int(nw * img_w)
-                    ph = int(nh * img_h)
-                    if pw <= 8 or ph <= 8:
-                        continue
-                    b64 = crop_and_b64(bgr_img, px, py, pw, ph)
-                    if not b64:
-                        continue
-                    item_obj = {
-                        "id": str(uuid.uuid4()),
-                        "label": label,
-                        "confidence": float(it.get("confidence", 0.5)),
-                        "bbox": {"x": px, "y": py, "w": pw, "h": ph},
-                        "thumbnail_b64": b64,
-                        "source": "gemini",
-                    }
-                    # Add placeholder analysis/title; will be filled later if analysis runs
-                    item_obj["analysis"] = {"type": "unknown", "summary": "", "brand": "", "tags": []}
-                    item_obj["title"] = "unknown"
-                    items_out.append(item_obj)
-                except Exception as e:
-                    log.warning("skipping item due to error: %s", e)
-        else:
-            log.info("Gemini returned no items or parse failed — using fallback contour crops.")
-            items_out = fallback_contour_crops(bgr_img, max_items=8)
-            # ensure analysis/title placeholders
-            for itm in items_out:
-                itm.setdefault("analysis", {"type": "unknown", "summary": "", "brand": "", "tags": []})
-                itm.setdefault("title", "unknown")
-
-        # Perform AI analysis per crop (if possible) and auto-upload to firebase with metadata (tmp + session)
-        if FIREBASE_ADMIN_JSON and FIREBASE_ADMIN_AVAILABLE:
-            try:
-                init_firebase_admin_if_needed()
-                bucket = fb_storage.bucket()
-            except Exception as e:
-                log.exception("Firebase admin init for upload failed: %s", e)
-                bucket = None
+def _heuristic_summary_from_inputs(user_inputs: Dict[str, Any]) -> str:
+    moods = user_inputs.get("moods") or []
+    brands = user_inputs.get("keyBrands") or []
+    events = user_inputs.get("events") or []
+    parts = []
+    if moods:
+        parts.append("moods: " + ", ".join(moods[:3]))
+    if brands:
+        parts.append("likes brands: " + ", ".join(brands[:3]))
+    if events:
+        parts.append("often for: " + ", ".join(events[:2]))
+    if not parts:
+        return "A user who likes simple, practical outfits."
+    return " & ".join(parts)
 
-            safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-            for itm in items_out:
-                b64 = itm.get("thumbnail_b64")
-                if not b64:
-                    continue
-                # analyze
-                try:
-                    analysis = analyze_crop_with_gemini(b64) if client else {"type": "unknown", "summary": "", "brand": "", "tags": []}
-                except Exception as ae:
-                    log.warning("analysis failed: %s", ae)
-                    analysis = {"type": "unknown", "summary": "", "brand": "", "tags": []}
-
-                # attach analysis and map to frontend category/title
-                itm["analysis"] = analysis
-                mapped_title = map_type_to_category(analysis.get("type", "") or itm.get("label", ""))
-                itm["title"] = mapped_title
-
-                item_id = itm.get("id") or str(uuid.uuid4())
-                path = f"detected/{safe_uid}/{item_id}.jpg"
-                try:
-                    metadata = {
-                        "tmp": "true",
-                        "session_id": session_id,
-                        "uploaded_by": safe_uid,
-                        "uploaded_at": str(int(time.time())),
-                        # store AI fields as JSON strings for later inspection
-                        "ai_type": analysis.get("type", ""),
-                        "ai_brand": analysis.get("brand", ""),
-                        "ai_summary": analysis.get("summary", ""),
-                        "ai_tags": json.dumps(analysis.get("tags", [])),
-                    }
-                    url = upload_b64_to_firebase(b64, path, content_type="image/jpeg", metadata=metadata)
-                    itm["thumbnail_url"] = url
-                    itm["thumbnail_path"] = path
-                    itm.pop("thumbnail_b64", None)
-                    itm["_session_id"] = session_id
-                    log.debug("Auto-uploaded thumbnail for %s -> %s (session=%s)", item_id, url, session_id)
-                except Exception as up_e:
-                    log.warning("Auto-upload failed for %s: %s", item_id, up_e)
-                    # keep thumbnail_b64 and analysis for client fallback
-        else:
-            if not FIREBASE_ADMIN_JSON:
-                log.info("FIREBASE_ADMIN_JSON not set; skipping server-side thumbnail upload.")
-            else:
-                log.info("Firebase admin SDK not available; skipping server-side thumbnail upload.")
-            # For items without firebase upload, still attempt local analysis mapping
-            for itm in items_out:
-                if "analysis" not in itm or not itm["analysis"]:
-                    # attempt lightweight analysis mapping using label
-                    itm.setdefault("analysis", {"type": itm.get("label", "unknown"), "summary": "", "brand": "", "tags": []})
-                mapped_title = map_type_to_category(itm["analysis"].get("type", "") or itm.get("label", ""))
-                itm["title"] = mapped_title
-
-        return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"raw_model_text": (raw_text or "")[:1600]}}), 200
-    except Exception as ex:
-        log.exception("Processing error: %s", ex)
-        try:
-            items_out = fallback_contour_crops(bgr_img, max_items=8)
-            for itm in items_out:
-                itm.setdefault("analysis", {"type": "unknown", "summary": "", "brand": "", "tags": []})
-                itm["title"] = map_type_to_category(itm["analysis"].get("type", "") or itm.get("label", ""))
-            return jsonify({"ok": True, "items": items_out, "session_id": session_id, "debug": {"error": str(ex)}}), 200
-        except Exception as e2:
-            log.exception("Fallback also failed: %s", e2)
-            return jsonify({"error": "internal failure", "detail": str(e2)}), 500
 
+# ---------- Flask app and endpoints ----------
 
-# ---------- Finalize endpoint: keep selected and delete only session's temp files ----------
+app = Flask(__name__)
+CORS(app)
 
 
-@app.route("/finalize_detections", methods=["POST"])
-def finalize_detections():
+@app.route("/suggest_candidates", methods=["POST"])
+def suggest_candidates():
     """
-    Body JSON: { "uid": "user123", "keep_ids": ["id1","id2",...], "session_id": "<session id from /process>" }
-
-    Server will delete only detected/<uid>/* files whose:
-        - metadata.tmp == "true"
-        - metadata.session_id == session_id
-        - item_id NOT in keep_ids
-
-    Returns:
-        { ok: True, kept: [...], deleted: [...], errors: [...] }
+    Step 1: Accepts wardrobe items and user inputs, returns candidate outfits.
+    Body JSON:
+      - uid (optional)
+      - wardrobe_items: array of items { id, title, analysis: {type,summary,brand,tags}, thumbnail_url (optional), confidence (optional) }
+      - user_inputs: object
+      - max_candidates: optional int
+    Response: { ok: True, candidates: [...], user_summary: "...", debug: {...} }
     """
     try:
         body = request.get_json(force=True)
@@ -549,138 +538,140 @@ def finalize_detections():
         return jsonify({"error": "invalid json"}), 400
 
     uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-    keep_ids = set(body.get("keep_ids") or [])
-    session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()
+    wardrobe_items = body.get("wardrobe_items") or []
+    user_inputs = body.get("user_inputs") or {}
+    max_c = int(body.get("max_candidates") or 6)
 
-    if not session_id:
-        return jsonify({"error": "session_id required for finalize to avoid unsafe deletes"}), 400
-
-    if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:
-        return jsonify({"error": "firebase admin not configured"}), 500
+    if not isinstance(wardrobe_items, list) or not isinstance(user_inputs, dict):
+        return jsonify({"error": "wardrobe_items(list) and user_inputs(object) required"}), 400
 
+    # attempt to fetch user summary and recent usage from Firestore (graceful)
     try:
-        init_firebase_admin_if_needed()
-        bucket = fb_storage.bucket()
+        user_summary = get_or_create_user_summary(uid, user_inputs)
     except Exception as e:
-        log.exception("Firebase init error in finalize: %s", e)
-        return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500
-
-    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-    prefix = f"detected/{safe_uid}/"
-
-    kept = []
-    deleted = []
-    errors = []
+        log.warning("get_or_create_user_summary failed: %s", e)
+        user_summary = _heuristic_summary_from_inputs(user_inputs)
 
     try:
-        blobs = list(bucket.list_blobs(prefix=prefix))
-        for blob in blobs:
-            try:
-                name = blob.name
-                fname = name.split("/")[-1]
-                if "." not in fname:
-                    continue
-                item_id = fname.rsplit(".", 1)[0]
-
-                md = blob.metadata or {}
-                # only consider temporary files matching this session id
-                if str(md.get("session_id", "")) != session_id or str(md.get("tmp", "")).lower() not in ("true", "1", "yes"):
-                    continue
+        past_week_items = fetch_recent_suggestions(uid, days=7) or []
+    except Exception as e:
+        log.warning("fetch_recent_suggestions failed: %s", e)
+        past_week_items = []
 
-                if item_id in keep_ids:
-                    # ensure public URL available if possible
-                    try:
-                        blob.make_public()
-                        url = blob.public_url
-                    except Exception:
-                        url = f"gs://{bucket.name}/{name}"
-
-                    # extract AI metadata (if present)
-                    ai_type = md.get("ai_type") or ""
-                    ai_brand = md.get("ai_brand") or ""
-                    ai_summary = md.get("ai_summary") or ""
-                    ai_tags_raw = md.get("ai_tags") or "[]"
-                    try:
-                        ai_tags = json.loads(ai_tags_raw) if isinstance(ai_tags_raw, str) else ai_tags_raw
-                    except Exception:
-                        ai_tags = []
-                    kept.append(
-                        {
-                            "id": item_id,
-                            "thumbnail_url": url,
-                            "thumbnail_path": name,
-                            "analysis": {"type": ai_type, "brand": ai_brand, "summary": ai_summary, "tags": ai_tags},
-                        }
-                    )
-                else:
-                    try:
-                        blob.delete()
-                        deleted.append(item_id)
-                    except Exception as de:
-                        errors.append({"id": item_id, "error": str(de)})
-            except Exception as e:
-                errors.append({"blob": getattr(blob, "name", None), "error": str(e)})
-        return jsonify({"ok": True, "kept": kept, "deleted": deleted, "errors": errors}), 200
+    # generate candidates (Gemini or naive)
+    try:
+        candidates = generate_candidates_with_gemini(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
     except Exception as e:
-        log.exception("finalize_detections error: %s", e)
-        return jsonify({"error": "internal", "detail": str(e)}), 500
+        log.exception("candidate generation failed: %s", e)
+        candidates = naive_generate_candidates(wardrobe_items, user_inputs, {"summary": user_summary}, past_week_items, max_candidates=max_c)
 
+    # ensure thumbnails exist as None if missing
+    for c in candidates:
+        for it in c.get("items", []):
+            it.setdefault("thumbnail_url", it.get("thumbnail_url") or None)
 
-# ---------- Clear session: delete all temporary files for a session ----------
+    return jsonify({"ok": True, "candidates": candidates, "user_summary": user_summary}), 200
 
 
-@app.route("/clear_session", methods=["POST"])
-def clear_session():
+@app.route("/refine_candidates", methods=["POST"])
+def refine_candidates():
     """
-    Body JSON: { "session_id": "", "uid": "" }
-    Deletes all detected//* blobs where metadata.session_id == session_id and metadata.tmp == "true".
+    Step 2: Apply constraints and attach item metadata.
+    Body JSON:
+      - wardrobe_items: full items list
+      - candidates: candidates returned by /suggest_candidates
+      - constraints: { require_brands: [...], reject_brands: [...], past_week_items: [...], allow_rerun: bool }
+    Response: { ok: True, refined: [...], rerun_required: bool, rerun_hint: str, removed: [...] }
     """
     try:
         body = request.get_json(force=True)
     except Exception:
         return jsonify({"error": "invalid json"}), 400
 
-    session_id = (body.get("session_id") or request.args.get("session_id") or "").strip()
-    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
-
-    if not session_id:
-        return jsonify({"error": "session_id required"}), 400
+    wardrobe_items = body.get("wardrobe_items") or []
+    candidates = body.get("candidates") or []
+    constraints = body.get("constraints") or {}
 
-    if not FIREBASE_ADMIN_JSON or not FIREBASE_ADMIN_AVAILABLE:
-        return jsonify({"error": "firebase admin not configured"}), 500
+    if not isinstance(wardrobe_items, list) or not isinstance(candidates, list):
+        return jsonify({"error": "wardrobe_items(list) and candidates(list) required"}), 400
 
     try:
-        init_firebase_admin_if_needed()
-        bucket = fb_storage.bucket()
+        result = refine_candidates_with_constraints(candidates, wardrobe_items, constraints)
+        return jsonify({"ok": True, **result}), 200
     except Exception as e:
-        log.exception("Firebase init error in clear_session: %s", e)
-        return jsonify({"error": "firebase admin init failed", "detail": str(e)}), 500
+        log.exception("refine_candidates failed: %s", e)
+        return jsonify({"error": "internal", "detail": str(e)}), 500
 
-    safe_uid = "".join(ch for ch in uid if ch.isalnum() or ch in ("-", "_")) or "anon"
-    prefix = f"detected/{safe_uid}/"
 
-    deleted = []
-    errors = []
+@app.route("/finalize_suggestion", methods=["POST"])
+def finalize_suggestion():
+    """
+    Step 3: Finalize a candidate and return a suggestion object.
+    Body JSON:
+      - uid (optional)
+      - candidate (object) OR candidate_id + candidates (list)
+      - user_inputs (optional)
+      - user_profile (optional)
+    Response:
+      { ok: True, suggestion: { id, items, thumbnail_urls, note, createdAt, meta } }
+    """
     try:
-        blobs = list(bucket.list_blobs(prefix=prefix))
-        for blob in blobs:
-            try:
-                md = blob.metadata or {}
-                if str(md.get("session_id", "")) == session_id and str(md.get("tmp", "")).lower() in ("true", "1", "yes"):
-                    try:
-                        blob.delete()
-                        deleted.append(blob.name.split("/")[-1].rsplit(".", 1)[0])
-                    except Exception as de:
-                        errors.append({"blob": blob.name, "error": str(de)})
-            except Exception as e:
-                errors.append({"blob": getattr(blob, "name", None), "error": str(e)})
-        return jsonify({"ok": True, "deleted": deleted, "errors": errors}), 200
-    except Exception as e:
-        log.exception("clear_session error: %s", e)
-        return jsonify({"error": "internal", "detail": str(e)}), 500
+        body = request.get_json(force=True)
+    except Exception:
+        return jsonify({"error": "invalid json"}), 400
+
+    uid = (body.get("uid") or request.args.get("uid") or "anon").strip() or "anon"
+    candidate = body.get("candidate")
+    if not candidate:
+        candidate_id = body.get("candidate_id")
+        candidates = body.get("candidates") or []
+        if candidate_id and isinstance(candidates, list):
+            candidate = next((c for c in candidates if c.get("id") == candidate_id), None)
+
+    if not candidate:
+        return jsonify({"error": "candidate required (object or candidate_id + candidates)"}), 400
+
+    user_inputs = body.get("user_inputs") or {}
+    user_profile = body.get("user_profile") or {}
+
+    # attach thumbnails list
+    thumb_urls = [it.get("thumbnail_url") for it in candidate.get("items", []) if it.get("thumbnail_url")]
+
+    # create final note (Gemini or heuristic)
+    note = finalize_suggestion_note_with_gemini(candidate, user_inputs, user_profile)
+
+    suggestion = {
+        "id": candidate.get("id") or str(uuid.uuid4()),
+        "items": candidate.get("items", []),
+        "thumbnail_urls": thumb_urls,
+        "note": note,
+        "createdAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "createdAtTs": int(time.time()),
+        "meta": {"source": "server_pipeline", "user_inputs": user_inputs, "user_profile": user_profile},
+        "uid": uid,
+    }
+
+    # Try to persist suggestion into Firestore.collection("suggestions") if configured (graceful)
+    fs = init_firestore_if_needed()
+    if fs:
+        try:
+            col = fs.collection("suggestions")
+            doc_id = suggestion["id"]
+            col.document(doc_id).set(suggestion)
+            log.info("Persisted suggestion %s for uid=%s", doc_id, uid)
+        except Exception as e:
+            log.warning("Failed to persist suggestion to Firestore: %s", e)
+
+    return jsonify({"ok": True, "suggestion": suggestion}), 200
+
+
+# Basic health endpoint
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"ok": True, "time": int(time.time()), "gemini": bool(client), "firestore": bool(init_firestore_if_needed())}), 200
 
 
 if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
-    log.info("Starting server on 0.0.0.0:%d", port)
+    log.info("Starting suggestion server on 0.0.0.0:%d", port)
     app.run(host="0.0.0.0", port=port, debug=True)