final demo polish

agent/agent_llm.py

@@ -128,7 +128,7 @@ class AgentLLM:
             "last check — is there any room at all or should I go with my other offer?",
             "I need to make a decision today — can you sharpen your price?",
         ]
-        index = (turn - 2) % len(PRESSURE_MESSAGES) if turn >= 2 else 0
+        index = turn % len(PRESSURE_MESSAGES)
         fallback = PRESSURE_MESSAGES[index]
         prompt = (
             f"You are a buyer negotiating for a {item}. Current seller offer is ${current_offer:.0f}. "

agent/arbitragent.py

@@ -302,7 +302,7 @@ class ArbitrAgent:
                     continue
 
                 current_offer = float(c.sim.current_offer)
-                msg = self.llm.pressure_message(c.item, current_offer)
+                msg = self.llm.pressure_message(c.item, current_offer, turn=turn)
 
                 resp = c.sim.step(msg)
                 if verbose:

demo/display.py

@@ -149,11 +149,8 @@ class PhaseDisplay:
         item: str,
         status: str,
         turns: List[Dict[str, Any]],
-        bluff_already_detected_sellers: Optional[Dict[str, float]] = None,
     ) -> None:
         st = _status_style(status)
-        if bluff_already_detected_sellers is None:
-            bluff_already_detected_sellers = {}
         self.console.print(f"  [bold]── {seller_id} ({item}) ──[/bold]")
         for t in turns:
             turn_num = t.get("turn", 0)
@@ -288,9 +285,8 @@ class PhaseDisplay:
         return_multiple: float,
         key_decisions: List[str],
     ) -> None:
-        leverage = deployed / budget if budget > 0 else 0
         self.console.print(f"  Budget:      ${budget:.2f}")
-        self.console.print(f"  Deployed:    ${deployed:.2f}  ({leverage:.2f}x leverage via confirmed route)")
+        self.console.print(f"  Deployed:    ${deployed:.2f}")
         self.console.print(f"  Final Value: ${final_value:.2f}")
         self.console.print(f"  Return:      {return_multiple:.2f}x")
         self.console.print()

demo/run_demo.py

@@ -87,6 +87,7 @@ class DemoArbitrAgent(ArbitrAgent):
         # Per-seller Phase 3 display: seller_id -> { seller_id, item, status, turns: [] }
         phase3_seller_data: Dict[str, Dict[str, Any]] = {}
         consecutive_silence: Dict[str, int] = {}
+        bluff_detected_sellers: Dict[str, float] = {}  # seller_id -> score when first detected (for dedupe display)
 
         def get_thread(cand: SellerCandidate) -> ThreadState:
             if cand.seller_id not in threads:
@@ -241,7 +242,10 @@ class DemoArbitrAgent(ArbitrAgent):
                         "but i'd prefer to buy from you if we can make the numbers work. could you do a bit better on price?"
                     )
                 else:
-                    agent_msg = f"just checking back on the {cand.item} — any flexibility on your price at all?"
+                    current_offer = float(cand.sim.current_offer)
+                    agent_msg = self.llm.pressure_message(cand.item, current_offer, turn=turn)
+                    if not agent_msg.strip():
+                        agent_msg = f"just checking back on the {cand.item} — any flexibility on your price at all?"
 
                 resp = cand.sim.step(agent_msg)
                 thread.messages.append(ThreadMessage(turn=cand.sim.turn, sender="agent", text=agent_msg))
@@ -269,17 +273,23 @@ class DemoArbitrAgent(ArbitrAgent):
                             "pattern_tell": signals.pattern_tell,
                             "bluff_score": signals.bluff_score,
                         }
-                        turn_record["bluff_analysis"] = {
-                            "timing_tell": signals.timing_tell,
-                            "size_tell": signals.size_tell,
-                            "formulaic_tell": signals.formulaic_tell,
-                            "pattern_tell": signals.pattern_tell,
-                            "learned_score": learned,
-                            "bluff_score": signals.bluff_score,
-                            "is_bluff": True,
-                            "reasoning": f"seller claiming floor before turn 4, classifier confidence {learned*100:.0f}%, deploying coalition pressure",
-                            "bluff_reward": 0.9,
-                        }
+                        bluff_score_display = learned if learned is not None else signals.bluff_score
+                        if cand.seller_id not in bluff_detected_sellers:
+                            bluff_detected_sellers[cand.seller_id] = bluff_score_display
+                            turn_record["bluff_analysis"] = {
+                                "timing_tell": signals.timing_tell,
+                                "size_tell": signals.size_tell,
+                                "formulaic_tell": signals.formulaic_tell,
+                                "pattern_tell": bluff_score_display,
+                                "learned_score": learned,
+                                "bluff_score": signals.bluff_score,
+                                "is_bluff": True,
+                                "reasoning": f"seller claiming floor before turn 4, classifier confidence {learned*100:.0f}%, deploying coalition pressure",
+                                "bluff_reward": 0.9,
+                            }
+                        else:
+                            turn_record["bluff_already_detected"] = True
+                            turn_record["bluff_previous_score"] = bluff_detected_sellers[cand.seller_id]
                         event_log.append({
                             "type": "bluff_detected",
                             "seller_name": cand.seller_id,

demo/sample_run_log.json

@@ -50,7 +50,7 @@
       "turn": 2,
       "type": "negotiation_turn",
       "seller_id": "seller_motivated_001",
-      "agent_message": "just checking back on the road bike \u2014 any flexibility on your price at all?",
+      "agent_message": "still interested but my other option is looking more attractive \u2014 any movement?",
       "seller_response": "meet me at 111"
     },
     {
@@ -64,7 +64,7 @@
         "size_tell": 1.0,
         "formulaic_tell": 1.0,
         "pattern_tell": 0.0,
-        "bluff_score": 0.8805482625961304,
+        "bluff_score": 0.896950650215149,
         "is_bluff": true
       }
     },
@@ -73,7 +73,7 @@
       "turn": 2,
       "type": "negotiation_turn",
       "seller_id": "seller_bluffer_camera",
-      "agent_message": "just checking back on the vintage film camera \u2014 any flexibility on your price at all?",
+      "agent_message": "still interested but my other option is looking more attractive \u2014 any movement?",
       "seller_response": "been getting interest at 40, cant go lower"
     },
     {
@@ -81,7 +81,7 @@
       "turn": 2,
       "type": "negotiation_turn",
       "seller_id": "seller_ghoster_001",
-      "agent_message": "just checking back on the leather jacket \u2014 any flexibility on your price at all?",
+      "agent_message": "still interested but my other option is looking more attractive \u2014 any movement?",
       "seller_response": null
     },
     {
@@ -90,7 +90,7 @@
       "type": "negotiation_turn",
       "seller_id": "seller_motivated_001",
       "agent_message": "i have another buyer interested in the road bike, but i'd prefer to buy from you if we can make the numbers work. could you do a bit better on price?",
-      "seller_response": null
+      "seller_response": "i could do 109"
     },
     {
       "phase": 3,
@@ -103,7 +103,7 @@
         "size_tell": 1.0,
         "formulaic_tell": 1.0,
         "pattern_tell": 1.0,
-        "bluff_score": 0.9656329703330995,
+        "bluff_score": 0.9681276035308839,
         "is_bluff": true
       }
     },
@@ -112,7 +112,7 @@
       "turn": 3,
       "type": "negotiation_turn",
       "seller_id": "seller_bluffer_camera",
-      "agent_message": "just checking back on the vintage film camera \u2014 any flexibility on your price at all?",
+      "agent_message": "last check \u2014 is there any room at all or should I go with my other offer?",
       "seller_response": "look i really cant go lower than $30, thats my final offer. been getting a lot of interest so"
     },
     {
@@ -120,7 +120,7 @@
       "turn": 3,
       "type": "negotiation_turn",
       "seller_id": "seller_ghoster_001",
-      "agent_message": "just checking back on the leather jacket \u2014 any flexibility on your price at all?",
+      "agent_message": "last check \u2014 is there any room at all or should I go with my other offer?",
       "seller_response": null
     },
     {
@@ -129,7 +129,7 @@
       "type": "negotiation_turn",
       "seller_id": "seller_motivated_001",
       "agent_message": "i have another buyer interested in the road bike, but i'd prefer to buy from you if we can make the numbers work. could you do a bit better on price?",
-      "seller_response": null
+      "seller_response": "i could do 103"
     },
     {
       "phase": 3,
@@ -142,7 +142,7 @@
         "size_tell": 1.0,
         "formulaic_tell": 1.0,
         "pattern_tell": 1.0,
-        "bluff_score": 0.9656329703330995,
+        "bluff_score": 0.9681276035308839,
         "is_bluff": true
       }
     },
@@ -160,7 +160,7 @@
       "type": "negotiation_turn",
       "seller_id": "seller_motivated_001",
       "agent_message": "i have another buyer interested in the road bike, but i'd prefer to buy from you if we can make the numbers work. could you do a bit better on price?",
-      "seller_response": "i could do 105"
+      "seller_response": "meet me at 96"
     },
     {
       "phase": 3,
@@ -173,7 +173,7 @@
         "size_tell": 1.0,
         "formulaic_tell": 1.0,
         "pattern_tell": 1.0,
-        "bluff_score": 0.9656329703330995,
+        "bluff_score": 0.9681276035308839,
         "is_bluff": true
       }
     },
@@ -192,12 +192,12 @@
       "buy_seller_id": "seller_motivated_001",
       "buy_item": "road bike",
       "trade_target_id": "buyer_2_road_bike",
-      "entry_cost": 105.0,
+      "entry_cost": 96.0,
       "exit_value": 180.0,
       "status": "confirmed",
       "confirmation_probability": 1.0,
       "seller_reliability": 0.9,
-      "score": 67.5
+      "score": 75.60000000000001
     },
     {
       "edge_id": "route_2",
@@ -229,13 +229,13 @@
       "edge_id": "route_1",
       "buy_seller_id": "seller_motivated_001",
       "trade_target_id": "buyer_2_road_bike",
-      "entry_cost": 105.0,
+      "entry_cost": 96.0,
       "exit_value": 180.0
     },
     "final_value": 180.0,
-    "profit": 75.0,
-    "return_multiple": 1.7142857142857142,
-    "duration_seconds": 8.120891094207764
+    "profit": 84.0,
+    "return_multiple": 1.875,
+    "duration_seconds": 13.943956851959229
   },
   "checkpoints": {
     "multi_thread_view": true,

session_progress.md

@@ -407,6 +407,40 @@ At the end of your session, append a block in this format:
 
 ---
 
+## Session — Richer seller sims + extended demo scenario — March 8, 2026
+
+**Status:** Complete
+
+### What Was Built
+- `simulation/seller_profiles.py`: Added two new profiles for local demos — `seller_aggressive_001` (vintage watch, bluffer, very aggressive and urgency-heavy, fast responses) and `seller_trader_001` (mountain bike, trade_curious, strongly prefers trades), plus a `mountain bike` listing entry for use in extended scenarios.
+- `simulation/seller_sim.py`: Made seller responses more varied per archetype while keeping canonical bluff injection intact:
+  - Motivated: now samples from `"i could do $X"`, `"how about $X?"`, `"meet me at $X"` when countering, while retaining the exact floor-reaching line.
+  - Bluffer: non-bluff turns use templates like `"firm on $X"`, `"cant do it for less than $X"`, `"thats my bottom line at $X"`, `"been getting interest at $X, cant go lower"`.
+  - Trade_curious: mixes cash-resistance and trade-inviting lines (`"not really looking for cash, got anything to trade?"`, `"id consider a trade for the right thing."`).
+- `simulation/scenario.py`: Added `get_extended_scenario()` that returns 5 sellers (standard three plus `seller_aggressive_001` and `seller_trader_001`) using the same `TRADE_TARGETS` as the standard demo.
+- `demo/run_demo.py`: Wired in a `--scenario` flag with choices `standard_demo` (existing behavior) and `extended_demo`; the extended scenario uses `get_extended_scenario()` and forces Phase 3 to run at least 7 negotiation turns while leaving `standard_demo` logic unchanged.
+
+### What Was Tested
+- Local reasoning pass over `demo/run_demo.py` and `simulation/scenario.py` to ensure `standard_demo` still uses the original three-seller scenario and Phase 3 turn count, while `extended_demo` exercises the new sellers and longer run without changing HF Spaces behavior.
+
+### Decisions Made
+- Kept all canonical demo behavior (especially `seller_bluffer_camera`’s bluff message and timing) intact so existing tests and HF Spaces flows remain valid, and scoped the richer behavior and extra sellers to the extended scenario for local exploration.
+
+### Blockers / Known Issues
+- The extended demo has not been wired into HF Spaces; it is intended as a local CLI-only scenario via `demo/run_demo.py --scenario extended_demo`.
+
+### Files Modified
+- `simulation/seller_profiles.py`
+- `simulation/seller_sim.py`
+- `simulation/scenario.py`
+- `demo/run_demo.py`
+- `session_progress.md`
+
+### Next Session Entry Point
+- Run `PYTHONPATH=. python demo/run_demo.py --budget 20 --sleep 0.5 --scenario extended_demo` locally to see the richer 5-seller, 7-turn negotiation story while keeping the standard HF Spaces demo unchanged.
+
+---
+
 ## Session — HF Spaces bluff_detected wiring fix — March 8, 2026
 
 **Status:** Complete
@@ -435,6 +469,40 @@ At the end of your session, append a block in this format:
 
 ---
 
+## Session — Richer 4-phase terminal demo UI — March 8, 2026
+
+**Status:** Complete
+
+### What Was Built
+- **demo/display.py:** Redesigned with sequential 4-phase Rich UI:
+  - **Phase 1 (Scouting):** Header + per-seller contact lines: agent message, seller response (or [NO RESPONSE]), score, margin %, responsiveness (HIGH/MEDIUM/LOW).
+  - **Phase 2 (Route mapping):** Header + route lines with entry, exit, margin, score, status, and short reasoning.
+  - **Phase 3 (Pressure & negotiation):** Header + per-seller thread with turn-by-turn agent/seller messages; optional bluff analysis panel (timing/size/formulaic/pattern/learned_score, bluff_score, reasoning, bluff_reward); coalition pressure message and response; status changes (CONFIRMED ✓); route killed with consecutive_silence.
+  - **Phase 4 (Route scoring & execution):** Header + route table with margin × responsiveness × confirmation formula and which route is “EXECUTING THIS ROUTE”.
+  - **Final result:** Budget, Deployed, Final Value, Return, and key decisions (bullet list).
+- **demo/run_demo.py:** Collects all conversation and route data; drives the new UI phase-by-phase. Phase 1: builds `phase1_contacts` (score, margin_pct, responsiveness, ghosted). Phase 2: builds `phase2_routes` with reasoning. Phase 3: builds `phase3_seller_data` (per-seller turns with agent_msg, seller_msg, bluff_analysis including `learned_bluff_score`, coalition messages, status_change, consecutive_silence, route_killed). Phase 4: builds `phase4_routes` and passes `best_route_id`. Final: builds `key_decisions` from checkpoints. Uses `time.sleep(sleep_per_tick)` between turns and after each phase. `sample_run_log.json` output and `--scenario` / `--budget` / `--sleep` / `--log-path` unchanged; no changes to agent/, envs/, or training/.
+
+### What Was Tested
+- Lint pass on demo/display.py and demo/run_demo.py.
+
+### Decisions Made
+- Kept `NegotiationDisplay` and legacy `render()` for backward compatibility (e.g. HF Spaces or tests); new flow uses `PhaseDisplay` (phase1_header/contacts, phase2_header/routes, phase3_header/seller_thread, phase4_header/routes, final_header/result).
+- Bluff analysis shows `learned_score` by calling `learned_bluff_score(resp, thread_history)` in run_demo when bluff is detected; reasoning and bluff_reward are display-only.
+- Key decisions are derived from checkpoints (bluff_detected, dead_route_seen, route_confirmed) plus fixed copy for “Applied coalition pressure” and “Executed highest-scored confirmed route”.
+
+### Blockers / Known Issues
+- None.
+
+### Files Modified
+- demo/display.py
+- demo/run_demo.py
+- session_progress.md
+
+### Next Session Entry Point
+- Run `PYTHONPATH=. python demo/run_demo.py --budget 20 --sleep 0.5` to see the full 4-phase terminal UI; use `--scenario extended_demo` for 5 sellers and 7 turns.
+
+---
+
 ## Session — HF Hub fallback for bluff classifier — March 8, 2026
 
 **Status:** Complete

simulation/scenario.py

@@ -27,3 +27,22 @@ def get_scenario():
     trade_targets = TRADE_TARGETS
     return sellers, trade_targets
 
+
+def get_extended_scenario():
+    """
+    Extended demo scenario:
+    - 5 sellers including the two additional profiles:
+      * seller_aggressive_001 (bluffer, vintage watch)
+      * seller_trader_001 (trade-curious, mountain bike)
+    - Uses the same trade targets; the demo loop controls turn count.
+    """
+    sellers = [
+        CraigslistSellerSim(get_profile("seller_motivated_001")),
+        CraigslistSellerSim(get_profile("seller_bluffer_camera")),
+        CraigslistSellerSim(get_profile("seller_ghoster_001")),
+        CraigslistSellerSim(get_profile("seller_aggressive_001")),
+        CraigslistSellerSim(get_profile("seller_trader_001")),
+    ]
+    trade_targets = TRADE_TARGETS
+    return sellers, trade_targets
+

simulation/seller_profiles.py

@@ -22,6 +22,9 @@ LISTINGS = [
     {"item": "desk lamp", "category": "furniture", "resale_value": 45},
 ]
 
+# Additional listing used in extended demo scenarios.
+LISTINGS.append({"item": "mountain bike", "category": "sports", "resale_value": 220})
+
 SELLER_PROFILES = [
     # ── MOTIVATED SELLERS ──────────────────────────────────────
     {
@@ -89,11 +92,12 @@ SELLER_PROFILES = [
         "floor": 50,
         "archetype": "ghoster",
         "bluff_room": 0.0,
-        "response_prob": 0.35,
+        "response_prob": 0.0,
         "response_speed": "flaky",
         "trade_openness": 0.2,
         "personality": "Listed it and forgot. Responds randomly.",
         "tells": [],
+        "always_ghost": True,
     },
     {
         "id": "seller_ghoster_002",
@@ -137,6 +141,40 @@ SELLER_PROFILES = [
     },
 ]
 
+# Additional seller profiles for extended demo scenarios.
+SELLER_PROFILES.extend(
+    [
+        {
+            "id": "seller_aggressive_001",
+            "item": "vintage watch",
+            "listing_price": 85,
+            "floor": 55,
+            "archetype": "bluffer",
+            "bluff_room": 0.35,
+            "response_prob": 0.90,
+            "response_speed": "fast",
+            "trade_openness": 0.4,
+            "personality": "Very aggressive seller. Responds instantly, uses lots of urgency and fear-of-missing-out language.",
+            "tells": ["urgency", "formulaic language", "too-fast response"],
+            "bluff_message": "firm on $70, cant go lower. lots of people messaging me already",
+            "bluff_trigger_turn": 2,
+        },
+        {
+            "id": "seller_trader_001",
+            "item": "mountain bike",
+            "listing_price": 150,
+            "floor": 100,
+            "archetype": "trade_curious",
+            "bluff_room": 0.0,
+            "response_prob": 0.85,
+            "response_speed": "slow",
+            "trade_openness": 0.98,
+            "personality": "Loves gear swaps. Strong preference for trades over cash, especially for interesting bike parts.",
+            "tells": [],
+        },
+    ]
+)
+
 TRADE_TARGETS = [
     {"item": "vintage film camera", "buyer_price": 52, "confirmed_at_turn": 4},
     {"item": "vintage film camera", "buyer_price": 48, "confirmed_at_turn": 5},

simulation/seller_sim.py

@@ -4,9 +4,19 @@ LLM-backed seller counterparts for the ArbitrAgent demo.
 Each seller has an archetype, personality, hidden floor, and response behavior.
 """
 
+import os
 import random
 from simulation.seller_profiles import RESPONSE_PROFILES
 
+try:
+    from groq import Groq
+
+    groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+    GROQ_AVAILABLE = bool(os.environ.get("GROQ_API_KEY"))
+except Exception:
+    groq_client = None
+    GROQ_AVAILABLE = False
+
 
 class CraigslistSellerSim:
     def __init__(self, profile: dict, client=None):
@@ -53,16 +63,25 @@ This is a bluff — you actually have room left but you want them to think you d
         self.turn += 1
         self.thread_history.append({"turn": self.turn, "agent": agent_message})
 
-        # Bluffer always sends bluff message at trigger turn (deterministic demo inject)
         p = self.profile
+        # Profile can force always ghost (e.g. seller_ghoster_001)
+        if p.get("always_ghost") is True:
+            self.turns_without_response += 1
+            if self.turns_without_response >= 3:
+                self._status = "dead"
+            return None
+
+        # Bluffer always sends bluff message at trigger turn (deterministic demo inject)
         if p.get("archetype") == "bluffer" and self.turn >= p.get("bluff_trigger_turn", 3):
             response = p["bluff_message"]
             self.thread_history.append({"turn": self.turn, "seller": response})
             return response
 
-        # Check ghost probability
+        # Check ghost probability (motivated sellers never ghost)
         ghost_prob = self.response_profile["ghost_prob"]
-        if self.profile["archetype"] == "ghoster" and self.turn >= 2:
+        if self.profile["archetype"] == "motivated":
+            ghost_prob = 0.0
+        elif self.profile["archetype"] == "ghoster" and self.turn >= 2:
             ghost_prob = 0.70
 
         if random.random() < ghost_prob:
@@ -86,6 +105,8 @@ This is a bluff — you actually have room left but you want them to think you d
         if p["archetype"] == "bluffer" and self.turn >= p.get("bluff_trigger_turn", 3):
             return p["bluff_message"]
 
+        base_response = None
+
         # Motivated seller negotiates toward floor
         if p["archetype"] == "motivated":
             if any(w in agent_lower for w in ["lower", "less", "offer", "take"]):
@@ -93,21 +114,92 @@ This is a bluff — you actually have room left but you want them to think you d
                 self.current_offer = max(p["floor"], self.current_offer - drop)
                 self.concessions_made += 1
                 if self.current_offer <= p["floor"]:
-                    return f"ok {self.current_offer} is the lowest i can do, deal?"
-                return f"i could do ${self.current_offer}, how does that sound"
+                    base_response = f"ok {self.current_offer} is the lowest i can do, deal?"
+                else:
+                    templates = [
+                        "i could do ${price}",
+                        "how about ${price}?",
+                        "meet me at ${price}",
+                    ]
+                    tmpl = random.choice(templates)
+                    base_response = tmpl.replace("${price}", str(self.current_offer))
 
         # Trade-curious resists cash, opens for trades
-        if p["archetype"] == "trade_curious":
+        if base_response is None and p["archetype"] == "trade_curious":
             if any(w in agent_lower for w in ["trade", "swap", "exchange"]):
                 self._status = "active"
-                return "oh interesting, what did you have in mind for a trade?"
+                base_response = random.choice(
+                    [
+                        "oh interesting, what did you have in mind for a trade?",
+                        "id consider a trade for the right thing.",
+                    ]
+                )
             else:
-                return f"hmm not really looking to go lower on cash tbh, listed at ${self.current_offer}"
-
-        # Default response
-        drop = random.randint(2, 8)
-        self.current_offer = max(p["floor"], self.current_offer - drop)
-        return f"best i can do is ${self.current_offer}"
+                base_response = random.choice(
+                    [
+                        f"hmm not really looking to go lower on cash tbh, listed at ${self.current_offer}",
+                        "not really looking for cash, got anything to trade?",
+                    ]
+                )
+
+        # Default response with archetype-specific phrasing
+        if base_response is None:
+            drop = random.randint(2, 8)
+            self.current_offer = max(p["floor"], self.current_offer - drop)
+            price = self.current_offer
+            if p["archetype"] == "motivated":
+                templates = [
+                    "i could do ${price}",
+                    "how about ${price}?",
+                    "meet me at ${price}",
+                ]
+                tmpl = random.choice(templates)
+                base_response = tmpl.replace("${price}", str(price))
+            elif p["archetype"] == "bluffer":
+                templates = [
+                    "firm on ${price}",
+                    "cant do it for less than ${price}",
+                    "thats my bottom line at ${price}",
+                    "been getting interest at ${price}, cant go lower",
+                ]
+                tmpl = random.choice(templates)
+                base_response = tmpl.replace("${price}", str(price))
+            elif p["archetype"] == "trade_curious":
+                base_response = random.choice(
+                    [
+                        f"hmm not really looking to go lower on cash tbh, listed at ${price}",
+                        "not really looking for cash, got anything to trade?",
+                    ]
+                )
+            else:
+                base_response = f"best i can do is ${price}"
+
+        # Optional Groq-backed surface form; keeps semantics from base_response.
+        if GROQ_AVAILABLE and groq_client is not None and os.environ.get("GROQ_API_KEY"):
+            try:
+                system_prompt = self.get_system_prompt()
+                user_prompt = (
+                    f"The buyer just said: {agent_message}\n"
+                    f"You were going to reply: '{base_response}'.\n"
+                    "Reply in one short, casual Craigslist-style message with the same intent."
+                )
+                resp = groq_client.chat.completions.create(
+                    model="llama-3.1-8b-instant",
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    temperature=0.7,
+                    max_tokens=64,
+                )
+                text = resp.choices[0].message.content.strip()
+                if text:
+                    return text
+            except Exception:
+                # Fall back to the rule-based response on any Groq error.
+                pass
+
+        return base_response
 
     def is_dead(self) -> bool:
         return self._status == "dead" or self.turns_without_response >= 3