Update app.py

app.py

@@ -1,14 +1,13 @@
-# app.py — Gifty (revised)
-# 🎁 GIfty — Smart Gift Recommender
-# Data: ckandemir/amazon-products
-# Retrieval: MiniLM-L12-v2 embeddings + FAISS (cosine), with simple on-disk cache
-# DIY Generation: small instruct LMs via HF pipeline (default: flan-t5-small) with JSON validate+repair (no padding)
-# Greeting: short LLM completion
-# Image: SD-Turbo (optional)
-# UI: Gradio; Quick Examples; Budget RangeSlider; DIY JSON + readable card
-
-import os, re, json, random, hashlib, pathlib
-from typing import Dict, List, Tuple
+# app.py
+# 🎁 GIfty+ — Smart Gift Recommender (original Spaces app + Hybrid Ranker v2)
+# Dataset default: Danielos100/Amazon_products_clean  (override via DATASET_ID env)
+# Retrieval: sentence-transformers/all-MiniLM-L12-v2 (cosine on budget-filtered subset)
+# DIY: FLAN-only (strict prompts + sanitizers)
+# Message: FLAN-based, לא גנרי — סטוכסטי עם ולידציה ואנטי-דופליקציה
+# UI: Examples-table למעלה (קליק-טואו-פיל), טופס פתוח ומסודר בשורות, בלי JSON
+
+import os, re, json, hashlib, pathlib, random
+from typing import Dict, List, Tuple, Optional, Any
 
 import numpy as np
 import pandas as pd
@@ -16,31 +15,39 @@ import gradio as gr
 from datasets import load_dataset
 
 from sentence_transformers import SentenceTransformer
-import faiss
-
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForCausalLM, pipeline
-
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 import torch
-from diffusers import AutoPipelineForText2Image
+
+print(f"===== Application Startup at {pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
 
 # --------------------- Config ---------------------
-MAX_ROWS = int(os.getenv("MAX_ROWS", "8000"))
-TITLE = "# 🎁 GIfty — Smart Gift Recommender\n*Top-3 catalog picks + 1 DIY gift (JSON) + personalized message*"
+TITLE = "# 🎁 GIfty+ — Smart Gift Recommender\n*Top-3 catalog picks + 1 DIY gift + personalized message*"
 
-# Retrieval model (embedding)
+DATASET_ID    = os.getenv("DATASET_ID", "Danielos100/Amazon_products_clean")
+DATASET_SPLIT = os.getenv("DATASET_SPLIT", "train")
+
+MAX_ROWS = int(os.getenv("MAX_ROWS", "12000"))
 EMBED_MODEL_ID = os.getenv("EMBED_MODEL_ID", "sentence-transformers/all-MiniLM-L12-v2")
-EMBED_CACHE_DIR = os.getenv("EMBED_CACHE_DIR", "./.gifty_cache")
-pathlib.Path(EMBED_CACHE_DIR).mkdir(parents=True, exist_ok=True)
 
-# DIY generation model (text)
-GEN_MODEL_ID = os.getenv("GEN_MODEL_ID", "google/flan-t5-small")
-OUTPUT_LANG = os.getenv("OUTPUT_LANG", "en")  # "en" or "he"
-MAX_INPUT_TOKENS = int(os.getenv("MAX_INPUT_TOKENS", "360"))
-MAX_NEW_TOKENS = int(os.getenv("MAX_NEW_TOKENS", "260"))
-DIY_MAX_ATTEMPTS = int(os.getenv("DIY_MAX_ATTEMPTS", "4"))
+# ---- Writable cache dir (no /data requirement) ----
+def resolve_cache_dir() -> str:
+    candidates = []
+    if os.getenv("EMBED_CACHE_DIR"):
+        candidates.append(os.getenv("EMBED_CACHE_DIR"))
+    candidates += [os.path.join(os.getcwd(), ".gifty_cache"), "/tmp/.gifty_cache"]
+    for p in candidates:
+        try:
+            pathlib.Path(p).mkdir(parents=True, exist_ok=True)
+            test = pathlib.Path(p) / ".write_test"
+            with open(test, "w") as f: f.write("ok")
+            test.unlink(missing_ok=True)
+            return p
+        except Exception:
+            continue
+    return os.getcwd()
 
-# Image gen toggle
-ENABLE_IMAGE = os.getenv("ENABLE_IMAGE", "1") == "1"
+EMBED_CACHE_DIR = resolve_cache_dir()
+print(f"[CACHE] Using EMBED_CACHE_DIR={EMBED_CACHE_DIR}")
 
 # ===== UI options =====
 INTEREST_OPTIONS = [
@@ -48,51 +55,24 @@ INTEREST_OPTIONS = [
     "Gaming","Photography","Hiking","Movies","Crafts","Pets","Wellness","Collecting","Food",
     "Home decor","Science"
 ]
-
 OCCASION_UI = [
     "Birthday","Wedding / Engagement","Anniversary","Graduation","New baby","Housewarming",
     "Retirement","Holidays","Valentine’s Day","Promotion / New job","Get well soon"
 ]
-# Canonical tokens used in filtering/query
 OCCASION_CANON = {
-    "Birthday":"birthday",
-    "Wedding / Engagement":"wedding",
-    "Anniversary":"anniversary",
-    "Graduation":"graduation",
-    "New baby":"new_baby",
-    "Housewarming":"housewarming",
-    "Retirement":"retirement",
-    "Holidays":"holidays",
-    "Valentine’s Day":"valentines",
-    "Promotion / New job":"promotion",
-    "Get well soon":"get_well"
+    "Birthday":"birthday","Wedding / Engagement":"wedding","Anniversary":"anniversary",
+    "Graduation":"graduation","New baby":"new_baby","Housewarming":"housewarming",
+    "Retirement":"retirement","Holidays":"holidays","Valentine’s Day":"valentines",
+    "Promotion / New job":"promotion","Get well soon":"get_well"
 }
-
 RECIPIENT_RELATIONSHIPS = [
-    "Family - Parent",
-    "Family - Sibling",
-    "Family - Child",
-    "Family - Other relative",
-    "Friend",
-    "Colleague",
-    "Boss",
-    "Romantic partner",
-    "Teacher / Mentor",
-    "Neighbor",
-    "Client / Business partner",
+    "Family - Parent","Family - Sibling","Family - Child","Family - Other relative",
+    "Friend","Colleague","Boss","Romantic partner","Teacher / Mentor","Neighbor","Client / Business partner",
 ]
-
 MESSAGE_TONES = [
     "Formal","Casual","Funny","Heartfelt","Inspirational","Playful","Romantic","Appreciative","Encouraging",
 ]
-
-AGE_OPTIONS = {
-    "any":"any",
-    "kid (3–12)":"kids",
-    "teen (13–17)":"teens",
-    "adult (18–64)":"adult",
-    "senior (65+)":"senior",
-}
+AGE_OPTIONS = {"any":"any","kid (3–12)":"kids","teen (13–17)":"teens","adult (18–64)":"adult","senior (65+)":"senior"}
 GENDER_OPTIONS = ["any","female","male","nonbinary"]
 
 # Query expansion by interest
@@ -118,160 +98,190 @@ SYNONYMS = {
     "home decor":["home","decor","wall art","candle"],
     "science":["lab","experiment","STEM","microscope"],
 }
-
-# Relationship tokens (soft guidance to retrieval)
 REL_TO_TOKENS = {
-    "Family - Parent": ["parent", "family"],
-    "Family - Sibling": ["sibling", "family"],
-    "Family - Child": ["kids", "play", "family"],
-    "Family - Other relative": ["family", "relative"],
+    "Family - Parent": ["parent","family"],
+    "Family - Sibling": ["sibling","family"],
+    "Family - Child": ["kids","play","family"],
+    "Family - Other relative": ["family","relative"],
     "Friend": ["friendly"],
-    "Colleague": ["office", "work", "professional"],
-    "Boss": ["executive", "professional", "premium"],
-    "Romantic partner": ["romantic", "couple"],
-    "Teacher / Mentor": ["teacher", "mentor", "thank_you"],
-    "Neighbor": ["neighbor", "housewarming"],
-    "Client / Business partner": ["professional", "thank_you", "premium"],
+    "Colleague": ["office","work","professional"],
+    "Boss": ["executive","professional","premium"],
+    "Romantic partner": ["romantic","couple"],
+    "Teacher / Mentor": ["teacher","mentor","thank_you"],
+    "Neighbor": ["neighbor","housewarming"],
+    "Client / Business partner": ["professional","thank_you","premium"],
 }
 
 # --------------------- Data loading & schema ---------------------
-def _to_price_usd(x):
-    s = str(x).strip().replace("$","").replace(",","")
-    try: return float(s)
-    except: return np.nan
-
-def _infer_age_from_category(cat: str) -> str:
-    s = (cat or "").lower()
-    if any(k in s for k in ["baby","toddler","infant"]): return "kids"
-    if "toys & games" in s or "board games" in s or "toy" in s: return "kids"
-    if any(k in s for k in ["teen","young adult","ya"]): return "teens"
-    return "any"
-
-def _infer_occasion_tags(cat: str) -> str:
-    s = (cat or "").lower()
-    tags = set(["birthday"])  # default
-    if any(k in s for k in ["home & kitchen","furniture","home décor","home decor","garden","appliance","cookware","kitchen"]):
-        tags.update(["housewarming"])
-    if any(k in s for k in ["beauty","jewelry","watch","fragrance","cosmetic","makeup","skincare"]):
-        tags.update(["valentines","anniversary"])
-    if any(k in s for k in ["toys","board game","puzzle","lego","kids"]):
-        tags.update(["holidays"])
-    if any(k in s for k in ["office","stationery","notebook","pen","planner"]):
-        tags.update(["graduation","promotion"])
-    if any(k in s for k in ["electronics","camera","audio","headphones","gaming","computer"]):
-        tags.update(["holidays"])
-    if any(k in s for k in ["book","novel","literature"]):
-        tags.update(["graduation"])
-    if any(k in s for k in ["baby","maternity","newborn","stroller"]):
-        tags.update(["new_baby"])
-    if any(k in s for k in ["wedding","engagement","bridal"]):
-        tags.update(["wedding"])
-    if any(k in s for k in ["retirement","senior gifts"]):
-        tags.update(["retirement"])
-    if any(k in s for k in ["health","wellness","get well","recovery"]):
-        tags.update(["get_well"])
-    return ",".join(sorted(tags))
+_CURRENCY_RE = re.compile(r"[^\d.,\-]+")
+_NUM_RE = re.compile(r"(\d+(?:[.,]\d+)?)")
+_RANGE_SEP = re.compile(r"\s*(?:-|–|—|to)\s*")
+
+def _to_price_usd(x) -> float:
+    if pd.isna(x): return np.nan
+    s = str(x).strip().lower()
+    if _RANGE_SEP.search(s):
+        left = _RANGE_SEP.split(s)[0]
+        s = left
+    s = _CURRENCY_RE.sub(" ", s)
+    m = _NUM_RE.search(s.replace(",", "."))
+    try:
+        return float(m.group(1)) if m else np.nan
+    except Exception:
+        return np.nan
+
+def _first_present(df: pd.DataFrame, candidates: List[str]) -> Optional[str]:
+    cols_lower = {c.lower(): c for c in df.columns}
+    for c in candidates:
+        if c in df.columns: return c
+        if c.lower() in cols_lower: return cols_lower[c.lower()]
+    return None
+
+def _auto_price_col(df: pd.DataFrame) -> Optional[str]:
+    for c in df.columns:
+        s = df[c]
+        if pd.api.types.is_numeric_dtype(s):
+            nonneg = s.dropna()
+            if not nonneg.empty and (nonneg.between(0.5, 10000)).mean() > 0.6:
+                return c
+    for c in df.columns:
+        sample = df[c].astype(str).head(200).str.lower().str.contains(r"\$|₪|eur|usd|£|€|\d")
+        if sample.mean() > 0.5:
+            return c
+    return None
 
 def map_amazon_to_schema(df_raw: pd.DataFrame) -> pd.DataFrame:
-    cols = {c.lower().strip(): c for c in df_raw.columns}
-    get = lambda key: df_raw.get(cols.get(key, ""), "")
+    name_c = _first_present(df_raw, ["product name","title","name","product_title"])
+    desc_c = _first_present(df_raw, ["description","product_description","feature","about"])
+    cat_c  = _first_present(df_raw, ["category","categories","main_cat","product_category"])
+    price_c= _first_present(df_raw, ["selling price","price","current_price","list_price","price_amount","actual_price","price_usd"])
+    if price_c is None:
+        price_c = _auto_price_col(df_raw)
+    img_c  = _first_present(df_raw, ["image","image_url","imageurl","imUrl","img","img_url"])
+
     out = pd.DataFrame({
-        "name": get("product name"),
-        "short_desc": get("description"),
-        "tags": get("category"),
-        "price_usd": get("selling price").map(_to_price_usd) if "selling price" in cols else np.nan,
-        "age_range": "",
-        "gender_tags": "any",
-        "occasion_tags": "",
-        "persona_fit": get("category"),
-        "image_url": get("image") if "image" in cols else "",
+        "name": df_raw.get(name_c, pd.Series("", index=df_raw.index)),
+        "short_desc": df_raw.get(desc_c, pd.Series("", index=df_raw.index)),
+        "tags": df_raw.get(cat_c, pd.Series("", index=df_raw.index)),
+        "price_usd": df_raw.get(price_c, pd.Series(np.nan, index=df_raw.index)).map(_to_price_usd),
+        "image_url": df_raw.get(img_c, pd.Series("", index=df_raw.index)),
     })
-    out["name"] = out["name"].astype(str).str.strip().str.slice(0, 120)
-    out["short_desc"] = out["short_desc"].astype(str).str.strip().str.slice(0, 500)
+    out["name"] = out["name"].astype(str).str.strip().str.slice(0, 160)
+    out["short_desc"] = out["short_desc"].astype(str).str.strip().str.slice(0, 600)
     out["tags"] = out["tags"].astype(str).str.replace("|", ", ").str.lower()
-    out["persona_fit"] = out["persona_fit"].astype(str).str.lower()
-    out["occasion_tags"] = out["tags"].map(_infer_occasion_tags)
-    out["age_range"] = out["tags"].map(_infer_age_from_category).fillna("any")
     return out
 
-def build_doc(row: pd.Series) -> str:
-    return " | ".join([
-        str(row.get("name","")),
-        str(row.get("short_desc","")),
-        str(row.get("tags","")),
-        str(row.get("persona_fit","")),
-        str(row.get("occasion_tags","")),
-        str(row.get("age_range","")),
-    ])
+def extract_top_cat(tags: str) -> str:
+    s = (tags or "").lower()
+    if "|" in s: return s.split("|", 1)[0].strip()
+    if ">" in s: return s.split(">", 1)[0].strip()
+    return s.strip().split(",")[0] if s else ""
 
 def load_catalog() -> pd.DataFrame:
-    try:
-        ds = load_dataset("ckandemir/amazon-products", split="train")
-        raw = ds.to_pandas()
-    except Exception:
-        raw = pd.DataFrame({
-            "Product Name": ["Wireless Earbuds","Coffee Sampler","Strategy Board Game"],
-            "Description": [
-                "Compact earbuds with noise isolation and long battery life.",
-                "Four single-origin roasts from small roasters.",
-                "Modern eurogame for 2–4 players, 45–60 minutes."
-            ],
-            "Category": ["Electronics | Audio","Grocery | Coffee","Toys & Games | Board Games"],
-            "Selling Price": ["$59.00","$34.00","$39.00"],
-            "Image": ["","",""]
-        })
+    ds  = load_dataset(DATASET_ID, split=DATASET_SPLIT)
+    raw = ds.to_pandas()
+
     df = map_amazon_to_schema(raw).drop_duplicates(subset=["name","short_desc"])
-    # EDA cleanups: drop missing price, cap to <= 500
     df = df[pd.notna(df["price_usd"])].copy()
-    df = df[df["price_usd"] <= 500].reset_index(drop=True)
-    # limit rows
+    df = df[(df["price_usd"] > 0) & (df["price_usd"] <= 500)].reset_index(drop=True)
+
     if len(df) > MAX_ROWS:
         df = df.sample(n=MAX_ROWS, random_state=42).reset_index(drop=True)
-    df["doc"] = df.apply(build_doc, axis=1)
+
+    df["doc"] = (df["name"].fillna("") + " | " + df["tags"].fillna("") + " | " + df["short_desc"].fillna("")).str.strip()
+    df["top_cat"] = df["tags"].map(extract_top_cat)
+    df["blob"] = (df["name"].fillna("") + " " + df["tags"].fillna("") + " " + df["short_desc"].fillna("")).str.lower()
+
+    print(f"[DATA] dataset={DATASET_ID} split={DATASET_SPLIT} rows_final={len(df)}")
     return df
 
 CATALOG = load_catalog()
 
-# --------------------- Embeddings + FAISS (with simple cache) ---------------------
-class EmbeddingIndex:
-    def __init__(self, docs: List[str], model_id: str):
+# --------------------- Embeddings (with dataset-aware cache) ---------------------
+class EmbeddingBank:
+    def __init__(self, docs: List[str], model_id: str, dataset_tag: str):
         self.model_id = model_id
+        self.dataset_tag = dataset_tag
         self.model = SentenceTransformer(model_id)
         self.embs = self._load_or_build(docs)
-        self.index = faiss.IndexFlatIP(self.embs.shape[1])  # cosine via normalized vectors
-        self.index.add(self.embs)
 
-    def _cache_paths(self, n_docs: int) -> Tuple[str, str]:
-        h = hashlib.md5((self.model_id + f"|{n_docs}").encode()).hexdigest()[:10]
-        npy = os.path.join(EMBED_CACHE_DIR, f"emb_{h}.npy")
-        idx = os.path.join(EMBED_CACHE_DIR, f"faiss_{h}.index")
-        return npy, idx
+    def _cache_path(self, n_docs: int) -> str:
+        h = hashlib.md5((self.dataset_tag + "|" + self.model_id + f"|{n_docs}").encode()).hexdigest()[:10]
+        return os.path.join(EMBED_CACHE_DIR, f"emb_{h}.npy")
 
     def _load_or_build(self, docs: List[str]) -> np.ndarray:
-        npy_path, _ = self._cache_paths(len(docs))
-        if os.path.exists(npy_path):
+        path = self._cache_path(len(docs))
+        if os.path.exists(path):
             try:
-                embs = np.load(npy_path)
+                embs = np.load(path, mmap_mode="r")
                 if embs.shape[0] == len(docs):
+                    print("[EMB] mmap-loaded from cache")
                     return embs
             except Exception:
                 pass
-        # build
+        print("[EMB] Building embeddings…")
         embs = self.model.encode(docs, convert_to_numpy=True, normalize_embeddings=True, show_progress_bar=True)
         try:
-            np.save(npy_path, embs)
+            np.save(self._cache_path(len(docs)), embs)
+            embs = np.load(self._cache_path(len(docs)), mmap_mode="r")
+            print(f"[EMB] Saved & mmap-loaded: {embs.shape}")
         except Exception:
-            pass
+            print("[EMB] Cache save failed; using RAM only")
         return embs
 
-    def search(self, query: str, topn: int):
-        qv = self.model.encode([query], convert_to_numpy=True, normalize_embeddings=True)
-        sims, idxs = self.index.search(qv, topn)
-        return sims[0], idxs[0]
+    def query_vec(self, text: str) -> np.ndarray:
+        return self.model.encode([text], convert_to_numpy=True, normalize_embeddings=True)[0]
+
+EMB = EmbeddingBank(CATALOG["doc"].tolist(), EMBED_MODEL_ID, DATASET_ID)
 
-EMB_INDEX = EmbeddingIndex(CATALOG["doc"].tolist(), EMBED_MODEL_ID)
+# ---- tokens per item for fast overlap (used by recommender bonuses) ----
+_tok_rx = re.compile(r"[a-z0-9][a-z0-9\-']*")
+def _tok_set(text: str) -> set:
+    return set(_tok_rx.findall(str(text).lower()))
+if "tok_set" not in CATALOG.columns:
+    CATALOG["tok_set"] = (
+        CATALOG["name"].fillna("") + " " +
+        CATALOG["tags"].fillna("") + " " +
+        CATALOG["short_desc"].fillna("")
+    ).map(_tok_set)
+
+# ====================== Recommendations — Hybrid Ranker v2 ======================
+# דגש חזק יותר על תחביבים; Gender/Age מסננים בלבד; חיזוק Occasion; ריראנקר אופציונלי; גיוון (MMR)
+try:
+    from sentence_transformers import CrossEncoder
+except Exception:
+    CrossEncoder = None
+
+RERANK_MODEL_ID = os.getenv("RERANK_MODEL_ID", "cross-encoder/ms-marco-MiniLM-L-6-v2")
+_CE_MODEL = None
+
+def _load_cross_encoder():
+    global _CE_MODEL
+    if _CE_MODEL is not None:
+        return _CE_MODEL
+    if CrossEncoder is None:
+        return None
+    try:
+        _CE_MODEL = CrossEncoder(RERANK_MODEL_ID, device="cpu")
+        print(f"[RERANK] Loaded: {RERANK_MODEL_ID}")
+    except Exception as e:
+        print(f"[RERANK] Failed to load CE: {e}")
+        _CE_MODEL = None
+    return _CE_MODEL
+
+OCCASION_PRIORS = {
+    "valentines": [("jewelry",0.12),("chocolate",0.10),("candle",0.08),("romantic",0.08),("couple",0.08),("heart",0.06)],
+    "birthday":   [("fun",0.06),("game",0.06),("personalized",0.06),("gift set",0.05),("surprise",0.04)],
+    "anniversary":[("couple",0.10),("jewelry",0.10),("photo",0.08),("frame",0.06),("memory",0.06),("candle",0.06)],
+    "graduation": [("journal",0.10),("planner",0.08),("office",0.08),("coffee",0.06),("motivation",0.06)],
+    "housewarming":[("home",0.10),("kitchen",0.08),("decor",0.10),("candle",0.06),("serving",0.06)],
+    "new_baby":   [("baby",0.12),("nursery",0.10),("soft",0.06),("blanket",0.06)],
+    "retirement": [("relax",0.08),("hobby",0.08),("travel",0.06),("book",0.06)],
+    "holidays":   [("holiday",0.10),("winter",0.08),("chocolate",0.08),("cozy",0.06),("family",0.06)],
+    "promotion":  [("desk",0.10),("office",0.10),("premium",0.08),("organizer",0.06)],
+    "get_well":   [("cozy",0.10),("tea",0.08),("soothing",0.06),("care",0.06)],
+}
 
-# --------------------- Query building ---------------------
 def expand_with_synonyms(tokens: List[str]) -> List[str]:
     out = []
     for t in tokens:
@@ -282,321 +292,638 @@ def expand_with_synonyms(tokens: List[str]) -> List[str]:
     return out
 
 def profile_to_query(profile: Dict) -> str:
+    # דגש ×3 לתחביבים; ללא אזכור גיל/מגדר בנוסח כדי לא לתת משקל סמנטי
     inter = [i.lower() for i in profile.get("interests", []) if i]
-    expanded = expand_with_synonyms(inter)
-    expanded = expanded + expanded  # weight x2
+    expanded = expand_with_synonyms(inter) * 3
     rel_tokens = REL_TO_TOKENS.get(profile.get("relationship","Friend"), [])
+    occ = OCCASION_CANON.get(profile.get("occ_ui","Birthday"), "birthday")
+
     parts = []
-    if expanded: parts.append(", ".join(expanded))
+    if expanded:   parts.append(", ".join(expanded))
     if rel_tokens: parts.append(", ".join(rel_tokens))
-    occ = OCCASION_CANON.get(profile.get("occ_ui","Birthday"), "birthday")
     parts.append(occ)
-    age = profile.get("age_range","any")
-    if age != "any": parts.append(age)
-    g = (profile.get("gender","any") or "any").lower()
-    if g != "any": parts.append("women" if g=="female" else ("men" if g=="male" else "unisex"))
-    return " | ".join(parts)
-
-def _contains_ci(series: pd.Series, needle: str) -> pd.Series:
-    if not needle: return pd.Series(True, index=series.index)
-    return series.fillna("").str.contains(re.escape(needle), case=False, regex=True)
-
-def filter_business(df: pd.DataFrame, budget_min=None, budget_max=None,
-                    occasion_canon: str=None, age_range: str="any") -> pd.DataFrame:
-    m = pd.Series(True, index=df.index)
-    if budget_min is not None:
-        m &= df["price_usd"].fillna(0) >= float(budget_min)
-    if budget_max is not None:
-        m &= df["price_usd"].fillna(1e9) <= float(budget_max)
-    if occasion_canon:
-        m &= _contains_ci(df["occasion_tags"], occasion_canon)
-    if age_range and age_range != "any":
-        m &= (df["age_range"].fillna("any").isin([age_range, "any"]))
-    return df[m]
-
-def recommend_topk(profile: Dict, k: int=3) -> pd.DataFrame:
-    query = profile_to_query(profile)
-    sims, idxs = EMB_INDEX.search(query, topn=min(max(k*80, k), len(CATALOG)))
-    df_f = filter_business(
-        CATALOG,
-        budget_min=profile.get("budget_min"),
-        budget_max=profile.get("budget_max"),
-        occasion_canon=OCCASION_CANON.get(profile.get("occ_ui","Birthday"), "birthday"),
-        age_range=profile.get("age_range","any"),
-    )
-    if df_f.empty: df_f = CATALOG
-    df_f_idx = set(df_f.index.tolist())
-
-    # soft gender boost
-    def gender_tokens(g: str) -> List[str]:
-        g = (g or "any").lower()
-        if g == "female": return ["women","woman","female","her"]
-        if g == "male": return ["men","man","male","him"]
-        if g == "nonbinary": return ["unisex","gender neutral","they"]
-        return ["unisex"]
-
-    gts = gender_tokens(profile.get("gender","any"))
-    cand = []
-    for i, sim in zip(idxs, sims):
-        i = int(i)
-        if i in df_f_idx:
-            blob = f"{CATALOG.loc[i,'tags']} {CATALOG.loc[i,'short_desc']}".lower()
-            boost = 0.08 if any(t in blob for t in gts) else 0.0
-            cand.append((i, float(sim) + boost))
-    cand.sort(key=lambda x: -x[1])
-
-    seen, picks = set(), []
-    for gi, score in cand:
-        nm = CATALOG.loc[gi, "name"]
-        if nm in seen: continue
-        seen.add(nm)
-        picks.append((gi, score))
-        if len(picks) >= k: break
-
-    if not picks:
-        res = df_f.head(k).copy()
+    tail = f"gift ideas for a {profile.get('relationship','Friend')} for {occ}; likes {', '.join(inter) or 'general'}"
+    return " | ".join([p for p in parts if p]) + " | " + tail
+
+def _gender_ok_mask(gender: str) -> np.ndarray:
+    g = (gender or "any").lower()
+    blob = CATALOG["blob"]
+    has_male   = blob.str.contains(r"\b(men|man's|mens|male|for men)\b",  regex=True, na=False)
+    has_female = blob.str.contains(r"\b(women|woman's|womens|female|for women|dress)\b", regex=True, na=False)
+    has_unisex = blob.str.contains(r"\bunisex|gender neutral\b", regex=True, na=False)
+    if g == "female":
+        return (~has_male | has_unisex).to_numpy()
+    if g == "male":
+        return (~has_female | has_unisex).to_numpy()
+    return np.ones(len(blob), dtype=bool)
+
+def _mask_by_age(age: str, blob: pd.Series) -> np.ndarray:
+    # סינון בלבד (ללא עונש/משקל)
+    KIDS_RX = r"\b(?:kid|kids|child|children|toddler|baby|boys?|girls?|kid\'s|children\'s)\b"
+    TEEN_RX = r"\b(?:teen|teens|young adult|ya)\b"
+    is_kidsy = blob.str.contains(KIDS_RX, regex=True, na=False)
+    is_teen  = blob.str.contains(TEEN_RX,  regex=True, na=False)
+    if age in ("adult","senior"):
+        return (~is_kidsy).to_numpy()
+    if age == "teens":
+        return ((~is_kidsy) | is_teen).to_numpy()
+    if age == "kids":
+        return (is_kidsy | (~is_teen & is_kidsy)).to_numpy()
+    return np.ones(len(blob), dtype=bool)
+
+def _interest_bonus(profile: Dict, idx: np.ndarray) -> np.ndarray:
+    ints = [i.lower() for i in profile.get("interests", []) if i]
+    syns = [s for it in ints for s in SYNONYMS.get(it, [])]
+    vocab = set(ints + syns)
+    if not vocab or idx.size == 0:
+        return np.zeros(len(idx), dtype="float32")
+    counts = np.array([len(CATALOG["tok_set"].iat[i] & vocab) for i in idx], dtype="float32")
+    counts = np.clip(counts, 0, 6)
+    return 0.10 * counts  # משקל חזק לתחביבים
+
+def _occasion_bonus(idx: np.ndarray, occ_ui: str) -> np.ndarray:
+    slug = OCCASION_CANON.get(occ_ui or "Birthday", "birthday")
+    pri = OCCASION_PRIORS.get(slug, [])
+    if not pri or idx.size == 0:
+        return np.zeros(len(idx), dtype="float32")
+    bl = CATALOG["blob"].to_numpy()
+    out = np.zeros(len(idx), dtype="float32")
+    for j, i in enumerate(idx):
+        text = bl[i]
+        bonus = 0.0
+        for kw, w in pri:
+            if kw in text:
+                bonus += w
+        out[j] = min(bonus, 0.15)
+    return out
+
+def _minmax(x: np.ndarray) -> np.ndarray:
+    if x.size == 0: return x
+    lo, hi = float(np.min(x)), float(np.max(x))
+    if hi <= lo + 1e-9: return np.zeros_like(x)
+    return (x - lo) / (hi - lo)
+
+def _mmr_select(cand_idx: np.ndarray, scores: np.ndarray, k: int, lambda_: float=0.7) -> np.ndarray:
+    if cand_idx.size <= k:
+        order = np.argsort(-scores)
+        return cand_idx[order][:k]
+    picked = []
+    rest = list(range(len(cand_idx)))
+    rel = _minmax(scores)
+    V = np.asarray(EMB.embs, dtype="float32")[cand_idx]
+    V = V / (np.linalg.norm(V, axis=1, keepdims=True) + 1e-8)
+    while len(picked) < k and rest:
+        if not picked:
+            j = int(np.argmax(rel[rest]))
+            picked.append(rest.pop(j))
+            continue
+        sim_to_sel = []
+        for c in rest:
+            sims = V[c] @ V[picked].T
+            smax = float(sims if np.ndim(sims) == 0 else np.max(sims))
+            sim_to_sel.append(smax)
+        sim_to_sel = np.array(sim_to_sel, dtype="float32")
+        mmr = lambda_ * rel[rest] - (1 - lambda_) * sim_to_sel
+        j = int(np.argmax(mmr))
+        picked.append(rest.pop(j))
+    return cand_idx[np.array(picked, dtype=int)]
+
+def recommend_top3_budget_first(profile: Dict) -> pd.DataFrame:
+    # 1) סינון לפי תקציב + גיל (סינון בלבד) + מגדר (סינון בלבד)
+    lo = float(profile.get("budget_min", 0))
+    hi = float(profile.get("budget_max", 1e9))
+    m_price = (CATALOG["price_usd"].values >= lo) & (CATALOG["price_usd"].values <= hi)
+    m_age   = _mask_by_age(profile.get("age_range","any"), CATALOG["blob"])
+    m_gender_ok = _gender_ok_mask(profile.get("gender","any"))
+    base_mask = m_price & m_age & m_gender_ok
+    idx = np.where(base_mask)[0]
+    if idx.size == 0:
+        idx = np.where(m_price & m_gender_ok)[0]
+    if idx.size == 0:
+        lo2, hi2 = max(0, lo*0.8), (hi*1.2 if hi < 1e8 else hi)
+        m_price2 = (CATALOG["price_usd"].values >= lo2) & (CATALOG["price_usd"].values <= hi2)
+        idx = np.where(m_price2 & m_gender_ok)[0]
+    if idx.size == 0:
+        cheapest = np.argsort(CATALOG["price_usd"].values)[:3]
+        res = CATALOG.iloc[cheapest].copy()
         res["similarity"] = np.nan
-        return res[["name","short_desc","price_usd","occasion_tags","persona_fit","age_range","image_url","similarity"]]
+        return res[["name","short_desc","price_usd","image_url","similarity"]].reset_index(drop=True)
 
-    sel = [gi for gi,_ in picks]
-    res = CATALOG.loc[sel].copy()
-    res["similarity"] = [dict(picks).get(int(i), np.nan) for i in sel]
-    return res[["name","short_desc","price_usd","occasion_tags","persona_fit","age_range","image_url","similarity"]]
+    # 2) אמבדינג + מחיר + תחביבים + Occasion
+    q = profile_to_query(profile)
+    qv = EMB.query_vec(q).astype("float32")
+    X = np.asarray(EMB.embs, dtype="float32")[idx]
+    emb_sims = X @ qv
 
-# --------------------- LLM plumbing (DIY + Greeting) ---------------------
+    target_price = (lo + hi)/2.0 if hi > lo else hi
+    prices = CATALOG.iloc[idx]["price_usd"].to_numpy()
+    price_bonus = np.clip(0.12 - np.abs(prices - target_price)/max(target_price,1.0), 0, 0.12).astype("float32")
 
-def load_text_pipeline(model_id: str):
-    trust=True
-    if "flan" in model_id or "t5" in model_id:
-        tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=trust)
-        mdl = AutoModelForSeq2SeqLM.from_pretrained(model_id, trust_remote_code=trust)
-        return pipeline("text2text-generation", model=mdl, tokenizer=tok, device_map="auto", trust_remote_code=trust)
-    else:
-        tok = AutoTokenizer.from_pretrained(model_id, trust_remote_code=trust)
-        mdl = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=trust)
-        return pipeline("text-generation", model=mdl, tokenizer=tok, device_map="auto", trust_remote_code=trust)
+    int_bonus = _interest_bonus(profile, idx)
+    occ_bonus = _occasion_bonus(idx, profile.get("occ_ui","Birthday"))
 
-try:
-    DIY_PIPE = load_text_pipeline(GEN_MODEL_ID)
-except Exception as e:
-    DIY_PIPE = None
-    print("DIY LLM load failed:", e)
-
-# Small greeting model (can reuse DIY_PIPE)
-GREETING_PIPE = DIY_PIPE
-
-# ---- JSON helpers ----
-GENERIC_NAMES = {"diy gift","gift","personalized gift","handmade gift","custom gift","מתנה","מתנה אישית","עשה זאת בעצמך"}
-
-def _f(x, fb=0.0):
-    try: return float(x)
-    except: return float(fb)
-
-def try_parse_json(text: str):
-    if not text: return None
-    m = re.search(r"(\{[\s\S]*\})", text.strip())
-    if not m: return None
-    blob = m.group(1)
+    pre_score = emb_sims + price_bonus + int_bonus + occ_bonus
+
+    # 3) מועמדים
+    K1 = min(64, idx.size)
+    top_local = np.argpartition(-pre_score, K1-1)[:K1]
+    cand_idx = idx[top_local]
+
+    emb_norm   = _minmax(emb_sims[top_local])
+    price_norm = _minmax(price_bonus[top_local])
+    int_norm   = _minmax(int_bonus[top_local])
+    occ_norm   = _minmax(occ_bonus[top_local])
+
+    # 4) ריראנקר אופציונלי (אם אפשר)
     try:
-        return json.loads(blob)
+        from sentence_transformers import CrossEncoder as _CE
+        ce = _load_cross_encoder()
+        if ce is not None:
+            docs  = CATALOG.loc[cand_idx, "doc"].tolist()
+            pairs = [(q, d) for d in docs]
+            ce_raw  = np.array(ce.predict(pairs), dtype="float32")
+            ce_norm = _minmax(ce_raw)
+        else:
+            ce_norm = np.zeros_like(emb_norm)
     except Exception:
-        blob = re.sub(r",\s*}\s*$", "}", blob)
-        blob = re.sub(r",\s*\]", "]", blob)
-        try: return json.loads(blob)
-        except: return None
-
-def truncate_prompt(pipe, text: str, max_tokens: int) -> str:
-    tok = pipe.tokenizer
-    ids = tok(text, truncation=True, max_length=max_tokens, return_tensors=None).get("input_ids", [])
-    return tok.decode(ids, skip_special_tokens=True) if ids else text
-
-# ---- DIY prompt, validate & repair (no padding) ----
-
-def diy_prompt(profile: Dict) -> str:
-    lang = "English" if OUTPUT_LANG == "en" else "Hebrew"
-    name = profile.get("recipient_name","Recipient")
-    rel  = profile.get("relationship","Friend")
-    age  = profile.get("age_range","any")
-    gen  = profile.get("gender","any")
-    ints = ", ".join(profile.get("interests",[])) or "general"
-    occ  = profile.get("occ_ui","Birthday")
-    lo, hi = int(profile.get("budget_min",10)), int(profile.get("budget_max",100))
-
-    return "\n".join([
-        f"Invent ONE original DIY gift idea from scratch for this recipient. Write all VALUES in {lang}.",
-        "Return JSON ONLY with exactly these keys (and nothing else):",
-        "gift_name, overview, materials_needed, step_by_step_instructions, estimated_cost_usd, estimated_time_minutes",
-        "",
-        "Hard requirements:",
-        "- Strongly reflect the recipient's interests and the occasion.",
-        "- overview MUST mention the recipient by NAME and include relationship, age_group, gender, and the occasion.",
-        "- gift_name must be SPECIFIC (not generic), 4–10 words, include at least one interest keyword.",
-        f"- estimated_cost_usd between ${lo}-${hi}; estimated_time_minutes 20–240.",
-        "- materials_needed: at least 5 concise items with quantities.",
-        "- step_by_step_instructions: at least 6 practical, ordered steps.",
-        "Forbidden gift_name terms: DIY Gift, Gift, Personalized Gift, Handmade Gift, Custom Gift.",
-        "",
-        f"Recipient: name={name}; relationship={rel}; age_group={age}; gender={gen}.",
-        f"Interests: {ints}. Occasion: {occ}.",
-        "JSON:"
-    ])
-
-def diy_validate(g: dict, profile: Dict) -> Tuple[bool, List[str]]:
-    errs=[]
-    # keys
-    req=["gift_name","overview","materials_needed","step_by_step_instructions","estimated_cost_usd","estimated_time_minutes"]
-    for k in req:
-        if k not in g: errs.append(f"missing key: {k}")
-    # name
-    n=str(g.get("gift_name",""))
-    if not n.strip(): errs.append("gift_name empty")
-    if any(b in n.strip().lower() for b in GENERIC_NAMES): errs.append("gift_name generic")
-    if len(n.split())<3: errs.append("gift_name too short")
-    # overview mentions
-    ov=str(g.get("overview",""))
-    if profile.get("recipient_name","") and profile.get("recipient_name") not in ov: errs.append("overview missing recipient name")
-    for field,label in [("relationship","relationship"),("age_range","age_group"),("gender","gender"),("occ_ui","occasion")]:
-        val=str(profile.get(field,""))
-        if val and (val.split()[0] not in ov): errs.append(f"overview missing {label}")
-    # lists
-    mats=g.get("materials_needed", [])
-    steps=g.get("step_by_step_instructions", [])
-    if not isinstance(mats, list) or len(mats)<5: errs.append("materials_needed len < 5")
-    if not isinstance(steps, list) or len(steps)<6: errs.append("steps len < 6")
-    # numbers
-    lo, hi = _f(profile.get("budget_min",10),10), _f(profile.get("budget_max",100),100)
-    cost=_f(g.get("estimated_cost_usd"), -1)
-    if not (lo <= cost <= hi): errs.append(f"cost not in budget [{lo},{hi}]")
-    mins=int(_f(g.get("estimated_time_minutes"), -1))
-    if not (20 <= mins <= 240): errs.append("time not in 20..240")
-    return (len(errs)==0), errs
-
-def diy_repair_prompt(profile: Dict, last: dict, errors: List[str]) -> str:
-    lang = "English" if OUTPUT_LANG == "en" else "Hebrew"
-    return "\n".join([
-        f"Fix ONLY the following problems in this JSON. Keep the same idea and style. Return JSON ONLY. Write all VALUES in {lang}.",
-        "Errors:",
-        *[f"- {e}" for e in errors],
-        "JSON to fix:",
-        json.dumps(last, ensure_ascii=False)
-    ])
+        ce_norm = np.zeros_like(emb_norm)
+
+    # 5) ציון סופי (דגש חזק לתחביבים דרך int_norm + השאילתה)
+    final = (
+        0.56 * emb_norm +
+        0.26 * ce_norm +
+        0.10 * int_norm +
+        0.05 * occ_norm +
+        0.03 * price_norm
+    ).astype("float32")
+
+    # 6) גיוון MMR ובחירת טופ-3
+    pick_idx = _mmr_select(cand_idx, final, k=min(3, cand_idx.size), lambda_=0.7)
+
+    res = CATALOG.loc[pick_idx].copy()
+    pos = {int(cand_idx[i]): i for i in range(len(cand_idx))}
+    res["similarity"] = [float(final[pos[int(i)]]) for i in pick_idx]
+    return res[["name","short_desc","price_usd","image_url","similarity"]].reset_index(drop=True)
+
+# ====================== END Recommendations ======================
+
+
+# --------------------- DIY (FLAN-only) — strict prompts + sanitizers ---------------------
+print("transformers:", __import__("transformers").__version__, "| torch:", torch.__version__)
+DIY_MODEL_ID = os.getenv("DIY_MODEL_ID", "google/flan-t5-small")
+DIY_DEVICE = torch.device("cpu")
+MAX_INPUT_TOKENS = int(os.getenv("MAX_INPUT_TOKENS", "384"))
+DIY_MAX_NEW_TOKENS = int(os.getenv("DIY_MAX_NEW_TOKENS", "120"))
+
+INTEREST_ALIASES = {
+    "Reading": ["book", "novel", "literary"],
+    "Fashion": ["style", "chic", "silk"],
+    "Home decor": ["candle", "wall", "jar"],
+    "Technology": ["tech", "gadget", "usb"],
+    "Movies": ["film", "cinema", "poster"],
+}
+FALLBACK_NOUNS = ["Kit", "Set", "Bundle", "Box", "Pack"]
+
+_diy_cache = {}
+def _load_flan(mid: str):
+    if mid in _diy_cache: return _diy_cache[mid]
+    tok = AutoTokenizer.from_pretrained(mid, use_fast=True, trust_remote_code=True)
+    mdl = AutoModelForSeq2SeqLM.from_pretrained(mid, trust_remote_code=True, use_safetensors=True).to(DIY_DEVICE).eval()
+    _diy_cache[mid] = (tok, mdl)
+    print(f"[DIY] Loaded FLAN: {mid}")
+    return _diy_cache[mid]
+
+@torch.inference_mode()
+def _gen(tok, mdl, prompt: str, max_new_tokens=64, do_sample=False, temperature=0.9, top_p=0.95, seed=None) -> str:
+    if seed is None: seed = random.randint(1, 10_000_000)
+    random.seed(seed); torch.manual_seed(seed)
+    enc = tok(prompt, truncation=True, max_length=MAX_INPUT_TOKENS, return_tensors="pt")
+    enc = {k: v.to(DIY_DEVICE) for k,v in enc.items()}
+    kw = dict(max_new_tokens=max_new_tokens, eos_token_id=tok.eos_token_id, pad_token_id=tok.eos_token_id)
+    if do_sample:
+        kw.update(dict(do_sample=True, temperature=temperature, top_p=top_p))
+    else:
+        kw.update(dict(do_sample=False, num_beams=1))
+    out = mdl.generate(**enc, **kw)
+    return tok.decode(out[0], skip_special_tokens=True).strip()
+
+def _choose_interest_token(interests: List[str]) -> str:
+    for it in interests:
+        cand = INTEREST_ALIASES.get(it, [])
+        if cand: return random.choice(cand)
+    return (interests[0].split()[0].lower() if interests else "gift")
+
+def _title_case(s: str) -> str:
+    s = re.sub(r'\s+', ' ', s).strip()
+    s = re.sub(r'["“”‘’]+', '', s)
+    return " ".join([w.capitalize() for w in s.split()])
+
+def _sanitize_name(name: str, interests: List[str]) -> str:
+    bad = [r"^the name\b", r"\bmember of the family\b", r"^name\b", r"^title\b"]
+    for b in bad:
+        name = re.sub(b, "", name, flags=re.I).strip()
+    name = re.sub(r'[:\-–—]+$', "", name).strip()
+    alias = _choose_interest_token(interests)
+    base = name.lower()
+    if alias not in base:
+        tokens = [t for t in re.split(r"[\s\-]+", name) if t]
+        if len(tokens) < 4:
+            name = f"{alias.capitalize()} " + " ".join([t.capitalize() for t in tokens]) if tokens else f"{alias.capitalize()} {random.choice(FALLBACK_NOUNS)}"
+        else:
+            tokens.insert(1, alias.capitalize())
+            name = " ".join(tokens)
+    name = re.sub(r'\b(Home Decor:?\s*){2,}', 'Home Decor ', name, flags=re.I)
+    name = _title_case(name)[:80]
+    if len(name.split()) < 3:
+        noun = random.choice(FALLBACK_NOUNS)
+        name = f"{alias.capitalize()} {noun}"
+    return name
+
+def _split_list_text(s: str, seps: List[str]) -> List[str]:
+    s = s.strip()
+    for sep in seps:
+        if sep in s:
+            parts = [p.strip(" -•*.,;:") for p in s.split(sep)]
+            parts = [p for p in parts if p]
+            if len(parts) >= 2:
+                return parts
+    parts = [p.strip(" -•*.,;:") for p in re.split(r"[\n\r;]+", s)]
+    return [p for p in parts if p]
+
+def _coerce_materials(items: List[str]) -> List[str]:
+    out = []
+    for it in items:
+        it = re.sub(r'\s+', ' ', it).strip(" -•*.,;:")
+        if not it: continue
+        it = re.sub(r'(\b\w+\b)(?:\s+\1){2,}', r'\1', it, flags=re.I)
+        if len(it) > 60: it = it[:58] + "…"
+        if not re.search(r"\d", it):
+            it = it + " x1"
+        if it.lower() not in [x.lower() for x in out]:
+            out.append(it)
+        if len(out) >= 8: break
+    base = ["Small gift box x1","Decorative paper x2","Twine 2 m","Cardstock sheets x2","Double-sided tape x1","Stickers x8","Ribbon 1 m","Fine-tip marker x1"]
+    i = 0
+    while len(out) < 6 and i < len(base):
+        if base[i].lower() not in [x.lower() for x in out]:
+            out.append(base[i])
+        i += 1
+    return out[:8]
+
+def _coerce_steps(items: List[str]) -> List[str]:
+    out = []
+    for it in items:
+        it = it.strip(" -•*.,;:")
+        if not it: continue
+        it = re.sub(r'\s+', ' ', it)
+        if len(it) > 120: it = it[:118] + "…"
+        it = re.sub(r'^(?:\d+[\).\s-]*)', '', it)
+        it = it[0].upper() + it[1:] if it else it
+        out.append(it)
+        if len(out) >= 8: break
+    while len(out) < 6:
+        out.append(f"Refine and decorate step {len(out)+1}")
+    return out[:8]
+
+def _only_int(s: str) -> Optional[int]:
+    m = re.search(r"-?\d+", s)
+    return int(m.group()) if m else None
+
+def _clamp_num(v, lo, hi, default):
+    try:
+        x = float(v)
+        return int(min(max(x, lo), hi))
+    except:
+        return int((lo + hi) / 2 if default is None else default)
+
+def _build_json(profile: Dict, fields: Dict[str, Any]) -> Dict[str, Any]:
+    mats = _coerce_materials(fields.get("materials_needed", []))
+    steps = _coerce_steps(fields.get("steps", []))
+    cost = _clamp_num(fields.get("estimated_cost_usd"), profile["budget_min"], profile["budget_max"], default=None)
+    minutes = _clamp_num(fields.get("estimated_time_minutes"), 20, 180, default=60)
+    return {
+        "gift_name": fields.get("gift_name","DIY Gift Idea").strip()[:80],
+        "overview":  fields.get("overview","A practical handmade gift tailored to the recipient.").strip(),
+        "materials_needed": mats,
+        "steps": steps,
+        "estimated_cost_usd": cost,
+        "estimated_time_minutes": minutes,
+    }
 
 def diy_generate(profile: Dict) -> Tuple[dict, str]:
-    if DIY_PIPE is None:
-        return {}, "DIY model not loaded"
-    # attempt 1: creative
-    prompt = diy_prompt(profile)
-    pr = truncate_prompt(DIY_PIPE, prompt, MAX_INPUT_TOKENS)
-    out = DIY_PIPE(pr, do_sample=True, temperature=0.9, top_p=0.95, max_new_tokens=MAX_NEW_TOKENS, truncation=True)
-    if not isinstance(out, list): out=[out]
-    texts = [o.get("generated_text","") for o in out]
-    candidates = [try_parse_json(t) or {} for t in texts]
-
-    # pick first valid
-    for cand in candidates:
-        ok, errs = diy_validate(cand, profile)
-        if ok:
-            return cand, "ok"
-        last = cand
-
-    # repair loop (deterministic)
-    attempts = 1
-    while attempts < DIY_MAX_ATTEMPTS:
-        ok, errs = diy_validate(last, profile)
-        if ok:
-            return last, "ok"
-        fix_pr = diy_repair_prompt(profile, last, errs)
-        fix_pr = truncate_prompt(DIY_PIPE, fix_pr, MAX_INPUT_TOKENS)
-        fixed = DIY_PIPE(fix_pr, do_sample=False, max_new_tokens=MAX_NEW_TOKENS, truncation=True)
-        fixed = (fixed if isinstance(fixed, list) else [fixed])[0].get("generated_text","")
-        fixed = try_parse_json(fixed) or last
-        last = fixed
-        attempts += 1
-    return last, "partial"
-
-# ---- Greeting generation ----
-
-def greeting_prompt(profile: Dict) -> str:
-    tone = profile.get('tone','Heartfelt')
-    name = profile.get('recipient_name','Friend')
-    rel  = profile.get('relationship','Friend')
-    occ  = profile.get('occ_ui','Birthday')
-    ints = ", ".join(profile.get('interests', []))
-    age  = profile.get('age_range','any')
-    gen  = profile.get('gender','any')
-    return f"""
-Write a short greeting (2–3 sentences) in English for a gift card.
-Tone: {tone}
-Recipient: {name} ({rel})
-Occasion: {occ}
-Interests: {ints}
-Age group: {age}; Gender: {gen}
-Avoid emojis.
-"""
-
-def llm_generate_message(profile: Dict) -> str:
-    if GREETING_PIPE is None:
-        return (f"Dear {profile.get('recipient_name','Friend')}, happy {profile.get('occ_ui','Birthday').lower()}! "
-                f"Wishing you joy and wonderful memories.")
-    pr = truncate_prompt(GREETING_PIPE, greeting_prompt(profile), MAX_INPUT_TOKENS)
-    out = GREETING_PIPE(pr, do_sample=False, max_new_tokens=90, truncation=True)
-    out = out if isinstance(out, list) else [out]
-    txt = out[0].get("generated_text","")
-    return txt.strip() or (f"Dear {profile.get('recipient_name','Friend')}, happy {profile.get('occ_ui','Birthday').lower()}!")
+    tok, mdl = _load_flan(DIY_MODEL_ID)
+    p = {
+        "recipient_name": profile.get("recipient_name","Recipient"),
+        "relationship": profile.get("relationship","Friend"),
+        "occ_ui": profile.get("occ_ui","Birthday"),
+        "occasion": profile.get("occ_ui","Birthday"),
+        "interests": profile.get("interests",[]),
+        "budget_min": int(float(profile.get("budget_min",10))),
+        "budget_max": int(float(profile.get("budget_max",100))),
+        "age_range": profile.get("age_range","any"),
+        "gender": profile.get("gender","any")
+    }
+    lang = "English"
+    ints_str = ", ".join(p["interests"]) or "general"
+
+    # 1) NAME
+    prompt_name = (
+        f"Return ONLY a DIY gift NAME in Title Case (4–8 words). "
+        f"Must include at least one interest token from: {', '.join(sum(([it]+INTEREST_ALIASES.get(it,[]) for it in p['interests']), [])) or 'gift'}. "
+        f"Occasion: {p['occ_ui']}. Relationship: {p['relationship']}. Language: {lang}. "
+        "Forbidden: the words 'name', 'title', 'family'. No quotes, no trailing punctuation.\n"
+        "Examples:\n"
+        "Reading → Literary Candle Bookmark Kit\n"
+        "Technology → Gadget Cable Organizer Set\n"
+        "Home decor → Rustic Jar Candle Bundle\n"
+        "Output:"
+    )
+    raw_name = _gen(tok, mdl, prompt_name, max_new_tokens=24, do_sample=False)
+    name = _sanitize_name(raw_name, p["interests"])
+
+    # 2) OVERVIEW
+    prompt_over = (
+        f"Write EXACTLY 2 sentences in {lang} for a handmade gift called '{name}'. "
+        f"Mention {p['recipient_name']} ({p['relationship']}) and the occasion ({p['occ_ui']}). "
+        f"Explain how it reflects the interests: {ints_str}. "
+        "No lists, no emojis. Output only the two sentences."
+    )
+    overview = _gen(tok, mdl, prompt_over, max_new_tokens=80, do_sample=True, temperature=0.9, top_p=0.95)
 
-# --------------------- Image generation (SD-Turbo) ---------------------
+    # 3) MATERIALS
+    prompt_mat = (
+        f"List 6 concise materials with quantities to make '{name}' cheaply. "
+        f"Keep total within {p['budget_min']}-{p['budget_max']} USD. "
+        "Output ONLY a comma-separated list (e.g., 'glass jar x2, soy tealights x4, ...')."
+    )
+    mats_txt = _gen(tok, mdl, prompt_mat, max_new_tokens=96, do_sample=False)
+    materials = _split_list_text(mats_txt, [",", ";"])
 
-def load_image_pipeline():
-    if not ENABLE_IMAGE:
-        return None
-    try:
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        dtype = torch.float16 if torch.cuda.is_available() else torch.float32
-        pipe = AutoPipelineForText2Image.from_pretrained("stabilityai/sd-turbo", torch_dtype=dtype)
-        pipe.to(device)
-        return pipe
-    except Exception as e:
-        print("Image pipeline load failed:", e)
-        return None
+    # 4) STEPS
+    prompt_steps = (
+        f"Write 6 short imperative steps to make '{name}'. "
+        "Output ONLY a semicolon-separated list."
+    )
+    steps_txt = _gen(tok, mdl, prompt_steps, max_new_tokens=120, do_sample=True, temperature=0.9, top_p=0.95)
+    steps = _split_list_text(steps_txt, [";", "\n"])
 
-IMG_PIPE = load_image_pipeline()
+    # 5) COST
+    prompt_cost = (
+        f"Return ONE integer total cost in USD between {p['budget_min']}-{p['budget_max']}. Output NUMBER only."
+    )
+    cost_txt = _gen(tok, mdl, prompt_cost, max_new_tokens=6, do_sample=False)
+    cost = _only_int(cost_txt)
+
+    # 6) MINUTES
+    time_txt = _gen(tok, mdl, "Return ONE integer minutes between 20 and 180. Output NUMBER only.",
+                    max_new_tokens=6, do_sample=False)
+    minutes = _only_int(time_txt)
+
+    idea = _build_json(p, {
+        "gift_name": name,
+        "overview": overview,
+        "materials_needed": materials,
+        "steps": steps,
+        "estimated_cost_usd": cost,
+        "estimated_time_minutes": minutes,
+    })
+    return idea, "ok"
+
+# --------------------- Personalized Message (FLAN, מגוון + ולידציה) ---------------------
+# מבוסס אחד-לאחד על הקוד מהקולאב שלך, מותאם לשימוש ישיר באפליקציה
+MSG_MODEL_ID = "google/flan-t5-small"
+MSG_DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+TEMP_RANGE  = (0.88, 1.10)
+TOPP_RANGE  = (0.90, 0.96)
+REP_PENALTY = 1.12
+MSG_MAX_NEW_TOKENS = 90
+MSG_MAX_TRIES = 4
+_last_msg: Optional[str] = None
+_msg_tok, _msg_mdl = None, None
+
+TONE_STYLES: Dict[str, Dict[str, List[str]]] = {
+    "Formal": {
+        "system": "Write 2–3 refined sentences with professional courtesy and clarity.",
+        "rules": [
+            "You may begin with 'Dear {name},' but keep it concise.",
+            "Use precise vocabulary; avoid colloquialisms.",
+            "Conclude with a dignified line."
+        ],
+    },
+    "Casual": {
+        "system": "Write 2–3 relaxed sentences with natural, friendly language.",
+        "rules": [
+            "Keep it light and conversational.",
+            "Reference one concrete interest detail.",
+            "End upbeat without clichés."
+        ],
+    },
+    "Funny": {
+        "system": "Write 2–3 witty sentences with playful humor.",
+        "rules": [
+            "Add one subtle pun linked to the occasion or interests.",
+            "No slapstick; keep it tasteful.",
+            "End with a cheeky nudge."
+        ],
+    },
+    "Heartfelt": {
+        "system": "Write 2–3 warm, sincere sentences with genuine sentiment.",
+        "rules": [
+            "Open with an image or specific detail; avoid templates.",
+            "Let one verb carry the energy; minimal adjectives.",
+            "Close with a crisp, personal wish."
+        ],
+    },
+    "Inspirational": {
+        "system": "Write 2–3 uplifting sentences with forward-looking energy.",
+        "rules": [
+            "Honor a trait or effort implied by the interests.",
+            "Use a subtle metaphor; avoid grandiose platitudes.",
+            "Finish with a compact, future-facing line."
+        ],
+    },
+    "Playful": {
+        "system": "Write 2–3 lively sentences with bounce and rhythm.",
+        "rules": [
+            "Sneak a gentle internal rhyme or alliteration.",
+            "Keep syntax varied and musical.",
+            "Land on a spirited close."
+        ],
+    },
+    "Romantic": {
+        "system": "Write 2–3 intimate sentences, warm and elegant.",
+        "rules": [
+            "Reference a shared moment or interest; keep it subtle.",
+            "No clichés or over-sweet phrasing.",
+            "End with a soft, affectionate note."
+        ],
+    },
+    "Appreciative": {
+        "system": "Write 2–3 sentences that express genuine appreciation.",
+        "rules": [
+            "Name a specific quality or habit tied to the interests.",
+            "Avoid business thank-you clichés.",
+            "Close with concise gratitude."
+        ],
+    },
+    "Encouraging": {
+        "system": "Write 2–3 supportive sentences that motivate gently.",
+        "rules": [
+            "Acknowledge progress or perseverance (hinted by interests).",
+            "Offer one practical, hopeful sentiment.",
+            "Finish with a compact encouragement."
+        ],
+    },
+}
+BAN_PHRASES = [
+    "wishing you all the best",
+    "may your day be filled",
+    "on this special day",
+    "from the bottom of my heart",
+    "best wishes on your",
+    "warm wishes",
+]
+OPENERS = [
+    "Here’s to a moment that fits you perfectly:",
+    "A note made just for you:",
+    "Because you make celebrations easy to love:",
+    "For a day that sounds like you:",
+]
+CLOSERS = [
+    "Enjoy every bit—you’ve earned it.",
+    "Keep doing the things that light you up.",
+    "Here’s to more of what makes you, you.",
+    "Let this be a spark for the year ahead.",
+]
 
+def _msg_load():
+    global _msg_tok, _msg_mdl
+    if _msg_tok is None or _msg_mdl is None:
+        _msg_tok = AutoTokenizer.from_pretrained(MSG_MODEL_ID)
+        _msg_mdl = AutoModelForSeq2SeqLM.from_pretrained(MSG_MODEL_ID)
+        _msg_mdl.to(MSG_DEVICE).eval()
+    return _msg_tok, _msg_mdl
+
+def _norm(s: str) -> str:
+    return re.sub(r"\s+", " ", s or "").strip()
+
+def _sentences_n(s: str) -> int:
+    return len([p for p in re.split(r"(?<=[.!?])\s+", s.strip()) if p])
+
+def _contains_any(text: str, terms: List[str]) -> bool:
+    t = text.lower()
+    return any(term and term.lower() in t for term in terms)
+
+def _too_similar(a: str, b: str, n=3, thr=0.85) -> bool:
+    def ngrams(txt):
+        toks = re.findall(r"[a-zA-Z']+", txt.lower())
+        return set(tuple(toks[i:i+n]) for i in range(max(0, len(toks)-n+1)))
+    A, B = ngrams(a), ngrams(b)
+    if not A or not B: return False
+    j = len(A & B) / max(1, len(A | B))
+    return j >= thr
+
+def _clean_occasion(occ: str) -> str:
+    return (occ or "").replace("’","'").strip()
+
+def _build_prompt(profile: Dict[str, Any]) -> Tuple[str, Dict[str,str]]:
+    name = profile.get("recipient_name", "Friend")
+    rel  = profile.get("relationship", "Friend")
+    occ  = _clean_occasion(profile.get("occ_ui") or profile.get("occasion") or "Birthday")
+    tone = profile.get("tone", "Heartfelt")
+    ints = ", ".join(profile.get("interests", [])) or "general interests"
+
+    style = TONE_STYLES.get(tone, TONE_STYLES["Heartfelt"])
+    opener = random.choice(OPENERS)
+    closer = random.choice(CLOSERS)
+    spice  = random.choice([
+        "Use one concrete visual detail.",
+        "Shift the rhythm slightly in the second sentence.",
+        "Let one verb carry most of the energy; keep adjectives minimal.",
+        "Add a gentle internal rhyme."
+    ])
 
-def generate_gift_image_from_diy(diy: Dict):
-    if IMG_PIPE is None or not diy:
-        return None
-    name = diy.get('gift_name','gift')
-    ov = diy.get('overview','product photo of handmade gift')
-    prompt = (
-        f"{name}: {ov}. Style: product photo, soft studio lighting, minimal background, realistic, high detail."
-    )
-    try:
-        img = IMG_PIPE(
-            prompt,
-            num_inference_steps=2,
-            guidance_scale=0.0,
-            width=512, height=512
-        ).images[0]
-        return img
-    except Exception as e:
-        print("Image generation failed:", e)
-        return None
+    lines = [
+        "You are a skilled copywriter. Generate a short gift-card message in English (2–3 sentences).",
+        f"Recipient: {name} ({rel}). Occasion: {occ}. Interests: {ints}. Tone: {tone}.",
+        style["system"],
+        "Rules:",
+        *[f"- {r}" for r in style["rules"]],
+        f"- Avoid clichés such as: {', '.join(BAN_PHRASES)}.",
+        "- No emojis. No bullet points.",
+        "- Do not start with 'Dear' unless Tone is Formal.",
+        f"- Start with: \"{opener}\" (continue naturally, not as a header).",
+        f"- End with a natural line similar to: \"{closer}\" (rephrase; do not quote).",
+        f"- {spice}",
+        "Output only the message; no extra commentary.",
+    ]
+    return "\n".join(lines), dict(name=name, occ=occ)
+
+@torch.inference_mode()
+def generate_personal_message(profile: Dict[str, Any], seed: Optional[int]=None, previous_message: Optional[str]=None) -> Dict[str, Any]:
+    global _last_msg
+    tok, mdl = _msg_load()
+    if seed is None:
+        seed = random.randint(1, 10_000_000)
+
+    tried = []
+    for attempt in range(1, MSG_MAX_TRIES+1):
+        random.seed(seed); torch.manual_seed(seed)
+        prompt, need = _build_prompt(profile)
+        temp  = random.uniform(*TEMP_RANGE)
+        topp  = random.uniform(*TOPP_RANGE)
+
+        enc = tok(prompt, truncation=True, max_length=512, return_tensors="pt").to(MSG_DEVICE)
+        out_ids = mdl.generate(
+            **enc,
+            do_sample=True,
+            temperature=temp,
+            top_p=topp,
+            max_new_tokens=MSG_MAX_NEW_TOKENS,
+            repetition_penalty=REP_PENALTY,
+            pad_token_id=tok.eos_token_id,
+            eos_token_id=tok.eos_token_id,
+        )
+        text = _norm(tok.decode(out_ids[0], skip_special_tokens=True))
+
+        ok_len = 1 <= _sentences_n(text) <= 3
+        name_ok = _contains_any(text, [need["name"]])
+        occ_ok  = _contains_any(text, [need["occ"], need["occ"].split()[0]])
+        ban_ok  = not _contains_any(text, BAN_PHRASES)
+        prev    = previous_message or _last_msg
+        dup_ok  = (prev is None) or (not _too_similar(text, prev, n=3, thr=0.85))
+
+        if all([ok_len, name_ok, occ_ok, ban_ok, dup_ok]):
+            _last_msg = text
+            return {"message": text, "meta": {"tone": profile.get("tone","Heartfelt"),
+                                              "temperature": round(temp,2), "top_p": round(topp,2),
+                                              "seed": seed, "attempt": attempt, "model": MSG_MODEL_ID}}
+        tried.append({"text": text}); seed += 17
+
+    fallback = tried[-1]["text"] if tried else f"Happy {(_clean_occasion(profile.get('occ_ui') or 'day')).lower()}, {profile.get('recipient_name','Friend')}!"
+    _last_msg = fallback
+    return {"message": fallback, "meta": {"failed": True, "model": MSG_MODEL_ID, "tone": profile.get("tone","Heartfelt")}}
 
 # --------------------- Rendering ---------------------
-
 def md_escape(text: str) -> str:
     return str(text).replace("|","\\|").replace("*","\\*").replace("_","\\_")
 
-def render_top3_html(df: pd.DataFrame) -> str:
+def first_sentence(s: str, max_chars: int = 140) -> str:
+    s = (s or "").strip()
+    if not s: return ""
+    cut = s.split(". ")[0]
+    if len(cut) > max_chars: cut = cut[:max_chars-1] + "…"
+    return cut
+
+def render_top3_html(df: pd.DataFrame, age_label: str) -> str:
     if df is None or df.empty:
-        return "<em>No results found.</em>"
+        return "<em>No results found within the current filters.</em>"
     rows = []
     for _, r in df.iterrows():
         name = md_escape(r.get("name",""))
-        desc = md_escape(r.get("short_desc",""))
+        desc = md_escape(first_sentence(r.get("short_desc","")))
         price = r.get("price_usd")
         sim = r.get("similarity")
-        age = r.get("age_range","any")
         img = r.get("image_url","") or ""
         price_str = f"${price:.0f}" if pd.notna(price) else "N/A"
         sim_str = f"{sim:.3f}" if pd.notna(sim) else "—"
@@ -607,7 +934,7 @@ def render_top3_html(df: pd.DataFrame) -> str:
     <div style="font-weight:700;">{name}</div>
     <div style="font-size:0.95em;margin-top:4px;">{desc}</div>
     <div style="font-size:0.9em;margin-top:6px;opacity:0.8;">
-      Price: <b>{price_str}</b> · Age: <code>{age}</code> · Similarity: <code>{sim_str}</code>
+      Price: <b>{price_str}</b> · Age: <code>{age_label}</code> · Score: <code>{sim_str}</code>
     </div>
   </div>
   {img_html}
@@ -616,174 +943,133 @@ def render_top3_html(df: pd.DataFrame) -> str:
         rows.append(card)
     return "\n".join(rows)
 
-
-def render_diy_md(d: Dict) -> str:
-    if not d:
-        return "<em>DIY generation failed.</em>"
-    name = md_escape(d.get("gift_name",""))
-    ov   = md_escape(d.get("overview",""))
-    cost = d.get("estimated_cost_usd", "—")
-    mins = d.get("estimated_time_minutes", "—")
-    mats = d.get("materials_needed", [])
-    steps= d.get("step_by_step_instructions", [])
-    mats_md = "\n".join([f"- {md_escape(str(m))}" for m in mats]) if isinstance(mats, list) else "- —"
-    steps_md= "\n".join([f"{i+1}. {md_escape(str(s))}" for i,s in enumerate(steps)]) if isinstance(steps, list) else "1. —"
-    return f"""
-### DIY Gift — {name}
-
-{ov}
-
-**Estimated cost:** ${cost} · **Estimated time:** {mins} min
-
-**Materials needed:**
-{mats_md}
-
-**Step-by-step:**
-{steps_md}
-"""
-
 # --------------------- Gradio UI ---------------------
-CSS = """
-#examples { order: 1; }
-#form { order: 2; }
+with gr.Blocks(
+    title="🎁 GIfty — Recommender + DIY",
+    css="""
+#explain {opacity:.85;font-size:.92em;margin-bottom:8px;}
+/* הסתרת מסגרת/היילייט כתומים של טבלת הדוגמאות */
+.handsontable .wtBorder, .handsontable .htBorders, .handsontable .wtBorder.current { display: none !important; }
+.gr-dataframe table td:focus { outline: none !important; box-shadow: none !important; }
 """
-
-with gr.Blocks(css=CSS) as demo:
+) as demo:
     gr.Markdown(TITLE)
 
-    with gr.Column(elem_id="examples"):
-        gr.Markdown("### Quick examples")
-
-    with gr.Column(elem_id="form"):
-        with gr.Row():
-            recipient_name = gr.Textbox(label="Recipient name", value="Rotem")
-            relationship = gr.Dropdown(label="Relationship", choices=RECIPIENT_RELATIONSHIPS, value="Romantic partner")
-
-        with gr.Row():
-            interests = gr.CheckboxGroup(
-                label="Interests (select a few)", choices=INTEREST_OPTIONS,
-                value=["Reading","Fashion","Home decor"], interactive=True
-            )
-
-        with gr.Row():
-            occasion = gr.Dropdown(label="Occasion", choices=OCCASION_UI, value="Valentine’s Day")
-            age = gr.Dropdown(label="Age group", choices=list(AGE_OPTIONS.keys()), value="adult (18–64)")
-            gender = gr.Dropdown(label="Recipient gender", choices=GENDER_OPTIONS, value="female")
-
-        RangeSlider = getattr(gr, "RangeSlider", None)
-        if RangeSlider is not None:
-            budget_range = RangeSlider(label="Budget range (USD)", minimum=5, maximum=500, step=1, value=[30, 60])
-            budget_min, budget_max = None, None
-        else:
-            with gr.Row():
-                budget_min = gr.Slider(label="Min budget (USD)", minimum=5, maximum=500, step=1, value=30)
-                budget_max = gr.Slider(label="Max budget (USD)", minimum=5, maximum=500, step=1, value=60)
-            budget_range = gr.State(value=None)
-
-        tone = gr.Dropdown(label="Message tone", choices=MESSAGE_TONES, value="Romantic")
-
-        go = gr.Button("Get GIfty 🎯")
-
-        out_top3 = gr.HTML(label="Top-3 recommendations")
-        out_diy_json = gr.JSON(label="DIY Gift (JSON)")
-        out_diy_md   = gr.Markdown(label="DIY Gift (readable)")
-        out_gen_img  = gr.Image(label="DIY Gift image", type="pil")
-        out_msg      = gr.Markdown(label="Personalized message")
-
-        # examples (render on top via CSS)
-        if RangeSlider:
-            example_inputs = [interests, occasion, budget_range, recipient_name, relationship, age, gender, tone]
-            EXAMPLES = [
-                [["Reading","Fashion","Home decor"], "Valentine’s Day", [30,60], "Rotem", "Romantic partner", "adult (18–64)", "female", "Romantic"],
-                [["Technology","Movies"], "Birthday", [25,45], "Daniel", "Friend", "adult (18–64)", "male", "Funny"],
-                [["Gaming","Photography"], "Birthday", [30,120], "Omer", "Family - Sibling", "teen (13–17)", "male", "Playful"],
-                [["Home decor","Cooking"], "Housewarming", [25,45], "Noa", "Neighbor", "adult (18–64)", "any", "Appreciative"],
-            ]
-        else:
-            example_inputs = [interests, occasion, budget_min, budget_max, recipient_name, relationship, age, gender, tone]
-            EXAMPLES = [
-                [["Reading","Fashion","Home decor"], "Valentine’s Day", 30, 60, "Rotem", "Romantic partner", "adult (18–64)", "female", "Romantic"],
-                [["Technology","Movies"], "Birthday", 25, 45, "Daniel", "Friend", "adult (18–64)", "male", "Funny"],
-                [["Gaming","Photography"], "Birthday", 30, 120, "Omer", "Family - Sibling", "teen (13–17)", "male", "Playful"],
-                [["Home decor","Cooking"], "Housewarming", 25, 45, "Noa", "Neighbor", "adult (18–64)", "any", "Appreciative"],
-            ]
-
-    with gr.Column(elem_id="examples"):
-        gr.Examples(EXAMPLES, inputs=example_inputs)
-
-    # --- predict wiring ---
-    def ui_predict(
-        interests_list, occasion_val,
-        budget_rng_or_min,
-        maybe_max_or_name,
-        maybe_name_or_rel,
-        rel_or_age,
-        age_or_gender,
-        gender_or_tone,
-        tone_maybe=None
-    ):
-        # Disambiguate RangeSlider vs two Sliders
-        use_range = isinstance(budget_rng_or_min, (list, tuple))
-        if use_range:
-            bmin = float(budget_rng_or_min[0]); bmax = float(budget_rng_or_min[1])
-            name = str(maybe_max_or_name or "Friend")
-            rel  = str(maybe_name_or_rel or "Friend")
-            age_label = str(rel_or_age or "any")
-            gender_val = str(age_or_gender or "any")
-            tone_val   = str(gender_or_tone or "Heartfelt")
-        else:
-            bmin = float(budget_rng_or_min if budget_rng_or_min is not None else 20)
-            bmax = float(maybe_max_or_name if maybe_max_or_name is not None else 60)
-            name = str(maybe_name_or_rel or "Friend")
-            rel  = str(rel_or_age or "Friend")
-            age_label = str(age_or_gender or "any")
-            gender_val = str(gender_or_tone or "any")
-            tone_val   = str(tone_maybe or "Heartfelt")
+    # ===== EXAMPLES TABLE (Top, clickable) =====
+    gr.Markdown("### Quick examples (click a row to auto-fill)", elem_id="explain")
+
+    EXAMPLES = [
+        # interests, occasion, bmin, bmax, name, relationship, age_label, gender, tone
+        (["Technology","Movies"],            "Birthday",        25, 45, "Daniel", "Friend",           "adult (18–64)", "male",   "Funny"),
+        (["Art","Reading","Home decor"], "Anniversary", 30, 60, "Rotem",  "Romantic partner", "adult (18–64)", "female", "Romantic"),
+        (["Gaming","Photography"],           "Birthday",        30,120, "Omer",   "Family - Sibling", "teen (13–17)",  "male",   "Playful"),
+        (["Reading","Art"],                  "Graduation",      15, 35, "Maya",   "Friend",           "adult (18–64)", "female", "Heartfelt"),
+        (["Science","Crafts"],               "Holidays",        15, 30, "Adam",   "Family - Child",   "kid (3–12)",    "any",    "Encouraging"),
+    ]
+    EX_COLS = ["Recipient","Relationship","Interests","Occasion","Age group","Gender","Min $","Max $","Tone"]
+    EX_DF = pd.DataFrame([
+        [name, rel, " + ".join(interests), occ, age, gender, bmin, bmax, tone]
+        for (interests, occ, bmin, bmax, name, rel, age, gender, tone) in EXAMPLES
+    ], columns=EX_COLS)
+
+    ex_df = gr.Dataframe(value=EX_DF, interactive=False, wrap=True)
+    gr.Markdown("---")
+
+    # === Inputs (always open) ===
+    with gr.Row():
+        recipient_name = gr.Textbox(label="Recipient name", value="Daniel")
+        relationship   = gr.Dropdown(label="Relationship", choices=RECIPIENT_RELATIONSHIPS, value="Friend")
+    with gr.Row():
+        occasion       = gr.Dropdown(label="Occasion", choices=OCCASION_UI, value="Birthday")
+        age            = gr.Dropdown(label="Age group", choices=list(AGE_OPTIONS.keys()), value="adult (18–64)")
+        gender         = gr.Dropdown(label="Recipient gender", choices=GENDER_OPTIONS, value="male")
+    interests      = gr.CheckboxGroup(label="Interests (select a few)", choices=INTEREST_OPTIONS,
+                                      value=["Technology","Movies"], interactive=True)
+    with gr.Row():
+        budget_min     = gr.Slider(label="Min budget (USD)", minimum=5, maximum=500, step=1, value=25)
+        budget_max     = gr.Slider(label="Max budget (USD)", minimum=5, maximum=500, step=1, value=45)
+        tone           = gr.Dropdown(label="Message tone", choices=MESSAGE_TONES, value="Funny")
+
+    # Action button and outputs
+    go = gr.Button("Get GIfty")
+    gr.Markdown("### 🎯 Recommendations")
+    out_top3   = gr.HTML()
+    gr.Markdown("### 🛠️ DIY Gift")
+    out_diy_md = gr.Markdown()
+    gr.Markdown("### 💌 Personalized Message")
+    out_msg    = gr.Markdown()
+
+    # ---- row click handler (fill form) ----
+    def _on_example_select(evt: gr.SelectData):
+        r = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
+        if isinstance(r, (list, tuple)): r = r[0]
+        r = int(r)
+        row = EX_DF.iloc[r]
+        ints = [s.strip() for s in str(row["Interests"]).split("+")]
+        return (
+            ints, row["Occasion"], int(row["Min $"]), int(row["Max $"]),
+            row["Recipient"], row["Relationship"], row["Age group"], row["Gender"], row["Tone"]
+        )
 
+    ex_df.select(
+        _on_example_select,
+        outputs=[interests, occasion, budget_min, budget_max, recipient_name, relationship, age, gender, tone]
+    )
+
+    # ---- UI predict ----
+    def render_diy_md(j: dict) -> str:
+        if not j: return "_DIY generation failed._"
+        steps = j.get('step_by_step_instructions', j.get('steps', []))
+        parts = [
+            f"**{j.get('gift_name','(no name)')}**",
+            "",
+            j.get("overview","").strip(),
+            "",
+            "**Materials**",
+            "\n".join(f"- {m}" for m in j.get("materials_needed", [])),
+            "",
+            "**Steps**",
+            "\n".join(f"{i+1}. {s}" for i, s in enumerate(steps)),
+            "",
+            f"**Estimated cost:** ${j.get('estimated_cost_usd','?')} · **Time:** {j.get('estimated_time_minutes','?')} min"
+        ]
+        return "\n".join(parts)
+
+    def ui_predict(interests_list, occasion_val, bmin, bmax, name, rel, age_label, gender_val, tone_val):
+        try:
+            bmin = float(bmin); bmax = float(bmax)
+        except Exception:
+            bmin, bmax = 5.0, 500.0
         if bmin > bmax: bmin, bmax = bmax, bmin
 
-        age_range = AGE_OPTIONS.get(age_label, "any")
         profile = {
-            "recipient_name": name,
-            "relationship": rel,
+            "recipient_name": name or "Friend",
+            "relationship": rel or "Friend",
             "interests": interests_list or [],
             "occ_ui": occasion_val or "Birthday",
             "budget_min": bmin,
             "budget_max": bmax,
-            "budget_usd": bmax,
-            "age_range": age_range,
-            "gender": gender_val or "any",
+            "age_range": AGE_OPTIONS.get(age_label, "any"),
+            "gender": (gender_val or "any").lower(),
             "tone": tone_val or "Heartfelt",
         }
 
-        # retrieval
-        top3 = recommend_topk(profile, k=3)
-        top3_html = render_top3_html(top3)
+        top3 = recommend_top3_budget_first(profile)
+        top3_html = render_top3_html(top3, age_label)
 
-        # DIY gift (generate-from-scratch, JSON)
-        diy_json, diy_status = diy_generate(profile)
+        diy_json, _status = diy_generate(profile)
         diy_md = render_diy_md(diy_json)
 
-        # DIY image (optional)
-        diy_img = generate_gift_image_from_diy(diy_json)
-
-        # greeting
-        msg = llm_generate_message(profile)
+        msg_obj = generate_personal_message(profile)
+        msg = msg_obj["message"]
 
-        return top3_html, diy_json, diy_md, diy_img, msg
+        return top3_html, diy_md, msg
 
-    if RangeSlider:
-        go.click(
-            ui_predict,
-            [interests, occasion, budget_range, recipient_name, relationship, age, gender, tone],
-            [out_top3, out_diy_json, out_diy_md, out_gen_img, out_msg]
-        )
-    else:
-        go.click(
-            ui_predict,
-            [interests, occasion, budget_min, budget_max, recipient_name, relationship, age, gender, tone],
-            [out_top3, out_diy_json, out_diy_md, out_gen_img, out_msg]
-        )
+    go.click(
+        ui_predict,
+        [interests, occasion, budget_min, budget_max, recipient_name, relationship, age, gender, tone],
+        [out_top3, out_diy_md, out_msg]
+    )
 
 if __name__ == "__main__":
     demo.launch()