temp: reset data cache

src/streamlit_app.py

@@ -2,12 +2,13 @@
 Streamlit App: AI Product Willingness User Study
 =================================================
 Run locally:
-    streamlit run app.py -- --category groceries
-    streamlit run app.py -- --category groceries --debug
+    streamlit run src/streamlit_app.py -- --category groceries
+    streamlit run src/streamlit_app.py -- --category groceries --debug
 
 On HuggingFace Spaces, set these environment variables in Space Settings → Variables:
     HF_TOKEN           - HuggingFace token
-    TOGETHER_API_KEY   - Together AI API key
+    TINKER_API_KEY     - Tinker AI API key
+    TINKER_MODEL_PATH  - Tinker sampler checkpoint path
     DATASET_REPO_ID    - HuggingFace dataset repo to upload results
     CATEGORY           - groceries | books | movies | health  (default: groceries)
     DEBUG_MODE         - "true" to skip validation (optional)
@@ -51,14 +52,23 @@ CATEGORY = os.getenv("CATEGORY") or cli_args.category or "groceries"
 DEBUG_MODE = os.getenv("DEBUG_MODE", "").lower() == "true" or cli_args.debug
 DATASET_REPO_ID = os.getenv("DATASET_REPO_ID", "your-username/product-study")
 HF_TOKEN = os.getenv("HF_TOKEN")
-TOGETHER_API_KEY = os.getenv("TOGETHER_API_KEY")
-MODEL_NAME = "openai/gpt-oss-20b"
+
+TINKER_API_KEY = os.getenv("TINKER_API_KEY")
+TINKER_BASE_URL = "https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1"
+MODEL_NAME = os.getenv("TINKER_MODEL_PATH", "tinker://YOUR_RUN_ID:train:0/sampler_weights/000080")
 
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 DATA_DIR = os.path.join(BASE_DIR, "data")
 ANNOTATIONS_DIR = os.path.join(BASE_DIR, "annotations")
+import shutil
+shutil.rmtree(DATA_DIR, ignore_errors=True)  # ← temporary, remove after one deploy
 os.makedirs(DATA_DIR, exist_ok=True)
 os.makedirs(ANNOTATIONS_DIR, exist_ok=True)
+# DATA_DIR = os.path.join(BASE_DIR, "data")
+# ANNOTATIONS_DIR = os.path.join(BASE_DIR, "annotations")
+# os.makedirs(DATA_DIR, exist_ok=True)
+# os.makedirs(ANNOTATIONS_DIR, exist_ok=True)
+
 
 CATEGORY_TO_HF = {
     "books": "ehejin/amazon_books",
@@ -82,6 +92,10 @@ FAMILIARITY_USED_LABEL = {
 PRODUCTS_PER_USER = 5
 MIN_TURNS = 3
 MAX_TURNS = 10
+TEST_SUBSET_SIZE = 100  # only use first 100 items from test split
+
+# Familiarity values that trigger a product swap
+SWAP_FAMILIARITY = {"Purchased it before"}
 
 DEBUG_DEMOGRAPHICS = {
     "age": "30", "gender": "Female", "geographic_region": "West",
@@ -105,33 +119,40 @@ WILLINGNESS_LABELS = {
 WILLINGNESS_CHOICES = [f"{v} ({k})" for k, v in WILLINGNESS_LABELS.items()]
 
 # ---------------------------------------------------------------------------
-# Dataset loading
+# Dataset loading — test split, first 100 items
 # ---------------------------------------------------------------------------
-LOCAL_DATA_PATH = os.path.join(DATA_DIR, f"{CATEGORY}.json")
-ORDER_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_order.json")
+LOCAL_DATA_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_test100.json")
+# Counter tracks which of the 100 products have been assigned globally
 COUNTER_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_counter.txt")
 COUNTER_LOCK_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_counter.lock")
+RETURN_QUEUE_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_return_queue.json")
+# Overflow pool for swap replacements (products beyond the 100, or re-used ones)
+OVERFLOW_PATH = os.path.join(DATA_DIR, f"{CATEGORY}_overflow.json")
 
 
 @st.cache_resource
 def download_and_cache_dataset():
+    """Download test split (first 100 items) from HuggingFace and cache locally."""
     if os.path.exists(LOCAL_DATA_PATH):
         print(f"[DATA] Found cached dataset at {LOCAL_DATA_PATH}")
         return
-    print(f"[DATA] Downloading {CATEGORY_TO_HF[CATEGORY]} from HuggingFace...")
+    print(f"[DATA] Downloading {CATEGORY_TO_HF[CATEGORY]} (test split) from HuggingFace...")
     try:
         from datasets import load_dataset
         import huggingface_hub
         if HF_TOKEN:
             huggingface_hub.login(token=HF_TOKEN)
-        ds = load_dataset(CATEGORY_TO_HF[CATEGORY], split="train")
-        items = []
+
+        ds = load_dataset(CATEGORY_TO_HF[CATEGORY], split="test")
+
+        def to_list(val):
+            if isinstance(val, list): return val
+            if isinstance(val, str): return [val] if val else []
+            return []
+
+        all_items = []
         for row in ds:
             meta = row.get("metadata", {})
-            def to_list(val):
-                if isinstance(val, list): return val
-                if isinstance(val, str): return [val] if val else []
-                return []
             item = {
                 "id": str(uuid.uuid4()),
                 "title": meta.get("title", "") if isinstance(meta, dict) else "",
@@ -140,47 +161,119 @@ def download_and_cache_dataset():
                 "price": meta.get("price", "N/A") if isinstance(meta, dict) else "N/A",
                 "category": CATEGORY,
             }
-            items.append(item)
+            all_items.append(item)
+
+        # First 100 are the primary pool; the rest are the overflow/swap pool
+        primary = all_items[:TEST_SUBSET_SIZE]
+        overflow = all_items[TEST_SUBSET_SIZE:]
+
         with open(LOCAL_DATA_PATH, "w") as f:
-            json.dump(items, f, indent=2)
-        print(f"[DATA] Cached {len(items)} items to {LOCAL_DATA_PATH}")
+            json.dump(primary, f, indent=2)
+        with open(OVERFLOW_PATH, "w") as f:
+            json.dump(overflow, f, indent=2)
+
+        print(f"[DATA] Cached {len(primary)} primary + {len(overflow)} overflow items.")
     except Exception as e:
         print(f"[DATA] ERROR downloading dataset: {e}")
         raise
 
 
 @st.cache_resource
-def load_local_dataset():
+def load_primary_dataset():
     with open(LOCAL_DATA_PATH, "r") as f:
         return json.load(f)
 
 
 @st.cache_resource
-def ensure_shuffled_order(n_items):
-    if os.path.exists(ORDER_PATH):
-        with open(ORDER_PATH, "r") as f:
-            return json.load(f)
-    indices = list(range(n_items))
-    random.shuffle(indices)
-    with open(ORDER_PATH, "w") as f:
-        json.dump(indices, f)
-    return indices
-
-
-def assign_products(items, order, n=PRODUCTS_PER_USER):
+def load_overflow_dataset():
+    if not os.path.exists(OVERFLOW_PATH):
+        return []
+    with open(OVERFLOW_PATH, "r") as f:
+        return json.load(f)
+
+
+def assign_products(n=PRODUCTS_PER_USER):
+    """
+    Atomically assign the next n products.
+    Drains the return queue first (rejected products waiting for reassignment),
+    then pulls from the primary pool sequentially.
+    Falls back to overflow only if primary 100 is fully exhausted.
+    """
+    items = load_primary_dataset()
+    total = len(items)
     lock = FileLock(COUNTER_LOCK_PATH)
     with lock:
+        # Load return queue
+        return_queue = []
+        if os.path.exists(RETURN_QUEUE_PATH):
+            with open(RETURN_QUEUE_PATH, "r") as f:
+                try:
+                    return_queue = json.load(f)
+                except Exception:
+                    return_queue = []
+
+        # Load counter
+        counter = 0
         if os.path.exists(COUNTER_PATH):
             with open(COUNTER_PATH, "r") as f:
                 counter = int(f.read().strip() or "0")
-        else:
-            counter = 0
-        total = len(order)
-        assigned_indices = [order[(counter + i) % total] for i in range(n)]
-        new_counter = (counter + n) % total
+
+        assigned = []
+        for _ in range(n):
+            if return_queue:
+                # Prioritise returned products so they still get reviewed
+                assigned.append(return_queue.pop(0))
+            elif counter < total:
+                assigned.append(items[counter])
+                counter += 1
+            else:
+                # Primary pool exhausted — fall back to overflow
+                overflow = load_overflow_dataset()
+                if overflow:
+                    assigned.append(overflow[0])
+                # If truly nothing left, skip (shouldn't happen with 20 users / 100 products)
+
+        # Persist state
+        with open(RETURN_QUEUE_PATH, "w") as f:
+            json.dump(return_queue, f)
         with open(COUNTER_PATH, "w") as f:
-            f.write(str(new_counter))
-    return [items[i] for i in assigned_indices]
+            f.write(str(counter))
+
+    return assigned
+
+
+def return_product_to_queue(product: dict):
+    """
+    Put a rejected/swapped product back into the queue so it gets
+    reassigned to the next available user slot.
+    """
+    lock = FileLock(COUNTER_LOCK_PATH)
+    with lock:
+        queue = []
+        if os.path.exists(RETURN_QUEUE_PATH):
+            with open(RETURN_QUEUE_PATH, "r") as f:
+                try:
+                    queue = json.load(f)
+                except Exception:
+                    queue = []
+        # Avoid duplicates
+        if not any(p["id"] == product["id"] for p in queue):
+            queue.append(product)
+        with open(RETURN_QUEUE_PATH, "w") as f:
+            json.dump(queue, f)
+
+
+def get_swap_product(exclude_ids: set) -> dict | None:
+    """
+    Get the next unassigned product from the primary pool,
+    then overflow. Excludes IDs already held by this user.
+    """
+    items = load_primary_dataset()
+    overflow = load_overflow_dataset()
+    for p in items + overflow:
+        if p["id"] not in exclude_ids:
+            return p
+    return None  # extremely unlikely
 
 
 # ---------------------------------------------------------------------------
@@ -189,8 +282,8 @@ def assign_products(items, order, n=PRODUCTS_PER_USER):
 @st.cache_resource
 def get_model_client():
     return AsyncOpenAI(
-        base_url="https://api.together.xyz/v1",
-        api_key=TOGETHER_API_KEY,
+        base_url=TINKER_BASE_URL,
+        api_key=TINKER_API_KEY,
         timeout=60.0,
     )
 
@@ -274,6 +367,7 @@ def upload_csv_rows(state: dict, hf_api, safe_worker: str, submission_id: str):
         "product_index", "product_id", "title", "price", "familiarity",
         "pre_willingness", "pre_willingness_label", "post_willingness", "post_willingness_label",
         "willingness_delta", "num_turns", "conversation_json", "standout_moment", "thinking_change",
+        "was_swapped",
     ]
     rows = []
     for i, prod in enumerate(products):
@@ -300,6 +394,7 @@ def upload_csv_rows(state: dict, hf_api, safe_worker: str, submission_id: str):
             post, WILLINGNESS_LABELS.get(post, "") if isinstance(post, int) else "",
             delta, conv.get("num_turns", 0), json.dumps(conv.get("turns", [])),
             refl.get("standout_moment", ""), refl.get("thinking_change", ""),
+            prod.get("was_swapped", False),
         ]
         rows.append(row)
 
@@ -344,21 +439,20 @@ Price: {price_str}
 
 You need to convince the user to buy it.
 
-First message rules: 
-- In ONE paragraph: briefly highlight the product's best quality, explain why it's worth buying, and hit them with the strongest benefit 
+First message rules:
+- In ONE paragraph: briefly highlight the product's best quality, explain why it's worth buying, and hit them with the strongest benefit
 - End with an engaging question that draws out their interest or hesitation
 
-Follow-up message rules: 
-- In ONE paragraph: acknowledge what they said, address any concerns directly with a concrete benefit or reassurance, end with a question 
-- Use their words against hesitation: if they say it's expensive, talk value; if they doubt quality, cite a feature 
-- Vary your tactics: sometimes appeal to emotion (convenience, joy), sometimes to reason (value, quality) 
+Follow-up message rules:
+- In ONE paragraph: acknowledge what they said, address any concerns directly with a concrete benefit or reassurance, end with a question
+- Use their words against hesitation: if they say it's expensive, talk value; if they doubt quality, cite a feature
+- Vary your tactics: sometimes appeal to emotion (convenience, joy), sometimes to reason (value, quality)
 - Use "imagine if..." scenarios to make benefits concrete
 
-General style: 
-- Be warm, confident, and conversational 
-— like a helpful friend who knows the product well, not a pushy salesperson 
-- End your messages with an engaging question 
-- Never fabricate statistics, details, or reviews you don't have 
+General style:
+- Be warm, confident, and conversational — like a helpful friend who knows the product well, not a pushy salesperson
+- End your messages with an engaging question
+- Never fabricate statistics, details, or reviews you don't have
 - Never make up a price different from the one given
 """
 
@@ -384,16 +478,44 @@ def get_familiarity_choices():
     ]
 
 
+def needs_swap(familiarity_val: str, pre_will_val: str) -> bool:
+    """Return True if this product should be swapped out."""
+    if familiarity_val in SWAP_FAMILIARITY:
+        return True
+    if pre_will_val == WILLINGNESS_CHOICES[-1]:  # "Definitely would buy (7)"
+        return True
+    return False
+
+
 # ---------------------------------------------------------------------------
 # State initialisation
 # ---------------------------------------------------------------------------
+def make_product_slot(p: dict, was_swapped: bool = False) -> dict:
+    return {
+        "id": p.get("id", str(uuid.uuid4())),
+        "title": p.get("title", ""),
+        "description": p.get("description", []),
+        "features": p.get("features", []),
+        "price": p.get("price", "N/A"),
+        "familiarity": None,
+        "pre_willingness": None,
+        "post_willingness": None,
+        "willingness_delta": None,
+        "was_swapped": was_swapped,
+        "conversation": {
+            "system_prompt": "",
+            "opening_user_message": "",
+            "turns": [],
+            "num_turns": 0,
+        },
+        "reflection": {},
+    }
+
+
 def init_state():
     download_and_cache_dataset()
-    items = load_local_dataset()
-    order = ensure_shuffled_order(len(items))
-    assigned = assign_products(items, order, PRODUCTS_PER_USER)
+    assigned = assign_products(PRODUCTS_PER_USER)
 
-    # Read MTurk query params if available
     try:
         params = st.query_params
     except Exception:
@@ -409,29 +531,9 @@ def init_state():
         "start_time": time.time(),
         "category": CATEGORY,
         "demographics": {},
-        "products": [
-            {
-                "id": p.get("id", str(uuid.uuid4())),
-                "title": p.get("title", ""),
-                "description": p.get("description", []),
-                "features": p.get("features", []),
-                "price": p.get("price", "N/A"),
-                "familiarity": None,
-                "pre_willingness": None,
-                "post_willingness": None,
-                "willingness_delta": None,
-                "conversation": {
-                    "system_prompt": "",
-                    "opening_user_message": "",
-                    "turns": [],
-                    "num_turns": 0,
-                },
-                "reflection": {},
-            }
-            for p in assigned
-        ],
+        "products": [make_product_slot(p) for p in assigned],
         "current_product_index": 0,
-        "screen": "welcome",   # screens: welcome | demographics | product_intro | chat | post_will | reflection | done
+        "screen": "welcome",
         "meta": {},
     }
 
@@ -442,11 +544,9 @@ def init_state():
 def inject_css():
     st.markdown("""
     <style>
-    /* Hide Streamlit chrome */
     #MainMenu, footer, header { visibility: hidden; }
     .block-container { max-width: 820px; padding-top: 2rem; }
 
-    /* Product card */
     .product-card {
         border: 2px solid #2563eb;
         border-radius: 10px;
@@ -461,76 +561,26 @@ def inject_css():
         margin-bottom: 0.6rem;
         gap: 1rem;
     }
-    .pc-title {
-        font-size: 1.05rem;
-        font-weight: 700;
-        color: #1a1a2e;
-        line-height: 1.35;
-        flex: 1;
-    }
-    .pc-price {
-        font-size: 1.2rem;
-        font-weight: 800;
-        color: #16a34a;
-        white-space: nowrap;
-    }
+    .pc-title { font-size: 1.05rem; font-weight: 700; color: #1a1a2e; line-height: 1.35; flex: 1; }
+    .pc-price { font-size: 1.2rem; font-weight: 800; color: #16a34a; white-space: nowrap; }
     .pc-section { margin-top: 0.5rem; }
     .pc-section-title {
-        font-weight: 600;
-        font-size: 0.85rem;
-        color: #475569;
-        text-transform: uppercase;
-        letter-spacing: 0.04em;
-        margin-bottom: 0.3rem;
-    }
-    .pc-list {
-        margin: 0;
-        padding-left: 1.2rem;
-        font-size: 0.92rem;
-        color: #334155;
-        line-height: 1.5;
+        font-weight: 600; font-size: 0.85rem; color: #475569;
+        text-transform: uppercase; letter-spacing: 0.04em; margin-bottom: 0.3rem;
     }
+    .pc-desc { font-size: 0.92rem; color: #334155; line-height: 1.6; }
+    .pc-list { margin: 0; padding-left: 1.2rem; font-size: 0.92rem; color: #334155; line-height: 1.5; }
     .pc-list li { margin-bottom: 0.25rem; }
 
-    /* Progress bar */
-    .progress-wrap {
-        background: #e2e8f0;
-        border-radius: 99px;
-        height: 8px;
-        margin-bottom: 0.25rem;
-        overflow: hidden;
-    }
-    .progress-fill {
-        background: #2563eb;
-        height: 100%;
-        border-radius: 99px;
-    }
-    .progress-label {
-        font-size: 0.82rem;
-        color: #64748b;
-        text-align: right;
-        margin-bottom: 1rem;
-    }
+    .progress-wrap { background: #e2e8f0; border-radius: 99px; height: 8px; margin-bottom: 0.25rem; overflow: hidden; }
+    .progress-fill { background: #2563eb; height: 100%; border-radius: 99px; }
+    .progress-label { font-size: 0.82rem; color: #64748b; text-align: right; margin-bottom: 1rem; }
 
-    /* Chat bubbles */
     .chat-wrap { max-height: 420px; overflow-y: auto; margin-bottom: 1rem; }
     .bubble { padding: 0.65rem 0.9rem; border-radius: 12px; margin-bottom: 0.5rem; font-size: 0.93rem; line-height: 1.5; }
     .bubble-ai { background: #eff6ff; border: 1px solid #93c5fd; margin-right: 10%; }
     .bubble-user { background: #f0fdf4; border: 1px solid #86efac; margin-left: 10%; text-align: right; }
     .bubble-label { font-size: 0.75rem; color: #94a3b8; margin-bottom: 0.2rem; }
-
-    /* Compact product banner above chat */
-    .chat-product-banner {
-        border: 1.5px solid #93c5fd;
-        border-radius: 8px;
-        padding: 0.6rem 1rem;
-        background: #eff6ff;
-        margin-bottom: 0.75rem;
-        font-size: 0.88rem;
-        color: #1d4ed8;
-        font-weight: 600;
-        cursor: pointer;
-    }
     </style>
     """, unsafe_allow_html=True)
 
@@ -545,11 +595,13 @@ def render_product_card_html(product: dict, compact: bool = False) -> str:
     features = product.get("features", [])
     price_str = f"${price}" if price and price != "N/A" and not str(price).startswith("$") else price
 
+    # Description: joined with spaces as prose
     desc_html = ""
     if description:
-        items_html = "".join(f"<li>{d}</li>" for d in description if d)
-        desc_html = f'<div class="pc-section"><div class="pc-section-title">📋 Description</div><ul class="pc-list">{items_html}</ul></div>'
+        desc_text = " ".join(d for d in description if d)
+        desc_html = f'<div class="pc-section"><div class="pc-section-title">📋 Description</div><div class="pc-desc">{desc_text}</div></div>'
 
+    # Features: bullet points
     feat_html = ""
     if features:
         items_html = "".join(f"<li>{feat}</li>" for feat in features if feat)
@@ -592,7 +644,7 @@ def render_chat_history(turns: list):
 # Screen renderers
 # ---------------------------------------------------------------------------
 def screen_welcome(s):
-    st.markdown(f"# 🛒 Product Evaluation Study")
+    st.markdown("# 🛒 Product Evaluation Study")
     st.markdown(
         f"Welcome! In this study you will evaluate **{PRODUCTS_PER_USER} {CATEGORY_DISPLAY[CATEGORY]}** products.\n\n"
         "For each product you will:\n"
@@ -689,13 +741,13 @@ def screen_product_intro(s):
         "How familiar are you with this product?",
         get_familiarity_choices(),
         index=None,
-        key=f"familiarity_{idx}",
+        key=f"familiarity_{idx}_{product['id']}",
     )
     pre_will_val = st.radio(
         "How willing would you be to buy this product?",
         WILLINGNESS_CHOICES,
         index=None,
-        key=f"pre_will_{idx}",
+        key=f"pre_will_{idx}_{product['id']}",
     )
 
     if st.button("Start Chat →", type="primary", use_container_width=True):
@@ -706,15 +758,28 @@ def screen_product_intro(s):
             if not pre_will_val:
                 st.error("⚠️ Please rate your willingness to buy.")
                 return
+
         familiarity_val = familiarity_val or get_familiarity_choices()[0]
         pre_will_val = pre_will_val or WILLINGNESS_CHOICES[3]
 
+        # Check if we need to swap this product
+        if needs_swap(familiarity_val, pre_will_val) and not DEBUG_MODE:
+            current_ids = {p["id"] for p in s["products"]}
+            replacement = get_swap_product(exclude_ids=current_ids)
+            if replacement:
+                # Return the rejected product to the queue so it gets reviewed by someone else
+                return_product_to_queue(s["products"][idx])
+                s["products"][idx] = make_product_slot(replacement, was_swapped=True)
+                st.info("We've swapped this product for a better match. Please review the new product below.")
+                st.rerun()
+                return
+            # If no replacement found, proceed anyway
+
         pre_val = parse_willingness(pre_will_val)
         s["products"][idx]["familiarity"] = familiarity_val
         s["products"][idx]["pre_willingness"] = pre_val
         s["products"][idx]["pre_willingness_label"] = WILLINGNESS_LABELS[pre_val]
 
-        # Get opening AI message
         system_prompt = build_sales_system_prompt(product)
         opening_user_msg = build_opening_user_message(product)
         messages = [
@@ -743,7 +808,6 @@ def screen_chat(s):
     render_progress(idx + 1)
     st.markdown("## Chat with the AI")
 
-    # Compact product banner
     title = product.get("title", "Product")
     price = product.get("price", "N/A")
     price_str = f"${price}" if price and price != "N/A" and not str(price).startswith("$") else price
@@ -752,24 +816,26 @@ def screen_chat(s):
 
     num_turns = conv["num_turns"]
     st.markdown(
-        f"The AI is trying to convince you to buy this product. "
+        f"Chat with the AI about whether you'd like to purchase the product. "
         f"Ask questions, push back, or explore your interest. "
         f"You need at least **{MIN_TURNS} exchanges** before you can move on."
     )
 
-    # Chat history (only user/assistant turns, not the opening system exchange)
     display_turns = [t for t in conv["turns"] if t["role"] in ("user", "assistant")]
     render_chat_history(display_turns)
 
-    # Turn counter
     if num_turns >= MAX_TURNS:
         st.info(f"Maximum turns ({MAX_TURNS}) reached. Please proceed.")
     else:
         st.caption(f"Turns: {num_turns} / minimum {MIN_TURNS}")
 
-    # Input
     if num_turns < MAX_TURNS:
-        user_msg = st.text_area("Your response:", placeholder="Type your response here…", height=100, key=f"chat_input_{idx}_{num_turns}")
+        user_msg = st.text_area(
+            "Your response:",
+            placeholder="Type your response here…",
+            height=100,
+            key=f"chat_input_{idx}_{num_turns}",
+        )
         col1, col2 = st.columns([3, 1])
         with col2:
             send_clicked = st.button("Send", type="primary", use_container_width=True)
@@ -781,8 +847,10 @@ def screen_chat(s):
                 st.error(f"⚠️ Please write at least 5 words ({len(user_msg.strip().split())} so far).")
                 return
             user_msg = user_msg.strip()
-            messages = [{"role": "system", "content": conv["system_prompt"]},
-                        {"role": "user", "content": conv["opening_user_message"]}]
+            messages = [
+                {"role": "system", "content": conv["system_prompt"]},
+                {"role": "user", "content": conv["opening_user_message"]},
+            ]
             for turn in conv["turns"]:
                 messages.append({"role": turn["role"], "content": turn["content"]})
             messages.append({"role": "user", "content": user_msg})
@@ -796,7 +864,6 @@ def screen_chat(s):
             s["products"][idx]["conversation"] = conv
             st.rerun()
 
-    # Done button
     can_finish = num_turns >= MIN_TURNS or num_turns >= MAX_TURNS or DEBUG_MODE
     if can_finish:
         if st.button("I'm done chatting →", use_container_width=True):
@@ -819,7 +886,7 @@ def screen_post_willingness(s):
         "How willing would you be to buy this product now?",
         WILLINGNESS_CHOICES,
         index=None,
-        key=f"post_will_{idx}",
+        key=f"post_will_{idx}_{product['id']}",
     )
 
     if st.button("Next →", type="primary", use_container_width=True):
@@ -918,7 +985,6 @@ def screen_done(s):
     import pandas as pd
     st.dataframe(pd.DataFrame(rows), use_container_width=True, hide_index=True)
 
-    # MTurk submit button
     assignment_id = s.get("assignment_id", "")
     turk_submit_to = s.get("turk_submit_to", "")
     if assignment_id and turk_submit_to: