Target h4 directly for the section-title bullet (Gradio nests a prose wrapper div)

app.py

@@ -1,34 +1,41 @@
 """
-PropertyPilot v3 — AI Maintenance Assistant
-Design : Dark timeline / glass-card UI (property_pilot_app.py)
-Backend: Real FAISS + BGE embeddings + Qwen2.5 generation (propertypilot-v2)
-New    : Fiverr contractor search link
-"""
+PropertyPilot v2 — AI Maintenance Assistant
+Built from the merged notebook (Final_Project_Matan.ipynb): retrieval-grounded
+triage, contractor ranking, tone-matched generation, Slack dispatch, NYC-311 feed.
 
+Pipeline: tenant message -> retrieval (FAISS, MiniLM) -> triage + contractor rank
+          -> work order + tone-matched reply (Qwen2.5)
+Bonuses:  Slack ops-channel dispatch (+5%), NYC-311 live feed (+5%)
+"""
 import os
 import re
 import json
-import html
+import time
+from collections import Counter
 from datetime import datetime
+from threading import Thread
 
 import torch
+import torch.nn as nn
 import pandas as pd
 import faiss
 import gradio as gr
-import spaces
 import requests
 from sentence_transformers import SentenceTransformer
 from huggingface_hub import hf_hub_download
-from transformers import AutoTokenizer, AutoModelForCausalLM
-from peft import PeftModel
-from collections import Counter
+from transformers import (AutoTokenizer, AutoModelForCausalLM, TextIteratorStreamer,
+                           DistilBertModel, DistilBertTokenizerFast)
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+HF_REPO  = "propertypilot/property-pilot-tickets"   # canonical dataset + recommender repo
+HF_TOKEN = os.environ.get("HF_TOKEN") or None
 
-# ── Configuration ─────────────────────────────────────────────────────────────
-HF_REPO       = "propertypilot/property-pilot-tickets"
-HF_TOKEN      = os.environ.get("HF_TOKEN") or None
+# Slack webhook must be set as a Space Secret (Settings > Variables and secrets),
+# NEVER hardcoded here — a hardcoded webhook in a public Space lets anyone post
+# to the channel.
 SLACK_WEBHOOK = os.environ.get("SLACK_WEBHOOK_URL")
-GEN_MODEL     = "Qwen/Qwen2.5-1.5B-Instruct"
-LORA_REPO     = "propertypilot/property-pilot-generator"
+
+GEN_MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
 
 SLA_MAP = {
     "P1": "4 hours",
@@ -37,20 +44,14 @@ SLA_MAP = {
     "P4": "7-14 business days",
 }
 
-URGENCY_EMOJI = {"P1": "🔴", "P2": "🟠", "P3": "🔵", "P4": "🟢"}
-URGENCY_HEX   = {"P1": "#ff6b6b", "P2": "#ffc078", "P3": "#7bdc9f", "P4": "#7bb3f0"}
-
-URGENCY_STYLE = {
-    "P1": ("#3a1620", "#ff8fa3", "#5a2338"),
-    "P2": ("#3a2a12", "#ffc078", "#5a4018"),
-    "P3": ("#12301f", "#7bdc9f", "#1c4a30"),
-    "P4": ("#16213a", "#7bb3f0", "#1e3a5a"),
-}
-
-CATEGORY_ICONS = {
-    "Electrical": "⚡", "Plumbing": "💧", "Hvac": "🌡️", "Appliance": "🔧",
-    "Structural": "🏗️", "Pest": "🐛", "Security": "🔒", "Noise": "🔊",
-    "Elevator": "🛗", "Other": "📋",
+# The fine-tuned classifier only returns short codes (P1-P4); the rest of the
+# app (dataset rows, generation prompt, contractor logic) uses the full
+# descriptive urgency string, so map back to that for consistency.
+URGENCY_FULL = {
+    "P1": "P1 Emergency (4h)",
+    "P2": "P2 Urgent (24h)",
+    "P3": "P3 Standard (3-5d)",
+    "P4": "P4 Scheduled (7-14d)",
 }
 
 TONE_INSTRUCTIONS = {
@@ -61,7 +62,7 @@ TONE_INSTRUCTIONS = {
                            "Give a SPECIFIC date/time commitment."),
     "passive-aggressive": ("The tenant is passive-aggressive. Be extra warm and proactive. "
                            "Avoid any defensiveness. Thank them for flagging the issue."),
-    "polite-formal":      ("The tenant is polite and formal. Match their register exactly — "
+    "polite-formal":      ("The tenant is polite and formal. Match their register exactly -- "
                            "be professional, precise, and respectful."),
     "vague-confused":     ("The tenant is unsure about the problem. Be clear and patient. "
                            "Ask ONE specific clarifying question if the issue is ambiguous."),
@@ -69,26 +70,25 @@ TONE_INSTRUCTIONS = {
                            "Use a numbered list if helpful."),
 }
 
-# ── Fiverr contractor search ──────────────────────────────────────────────────
-FIVERR_KEYWORDS = {
-    "Electrical": "electrician+wiring+repair",
-    "Plumbing":   "plumber+pipe+leak+repair",
-    "Hvac":       "hvac+technician+air+conditioning+repair",
-    "Appliance":  "appliance+repair+technician",
-    "Structural": "contractor+structural+repair+construction",
-    "Pest":       "pest+control+exterminator",
-    "Security":   "locksmith+door+lock+repair",
-    "Noise":      "noise+mediation+soundproofing",
-    "Elevator":   "elevator+lift+technician+repair",
-    "Other":      "handyman+home+repair",
+URGENCY_EMOJI = {"P1": "🔴", "P2": "🟠", "P3": "🔵", "P4": "🟢"}
+URGENCY_HEX   = {"P1": "#FF0000", "P2": "#FF8C00", "P3": "#0099FF", "P4": "#00CC44"}
+
+YELP_KEYWORDS = {
+    "Plumbing":     "plumber",
+    "Electrical":   "electrician",
+    "HVAC":         "hvac+repair",
+    "Appliances":   "appliance+repair",
+    "Elevator":     "elevator+repair",
+    "Structural":   "contractor+structural+repair",
+    "Pests":        "pest+control",
+    "Common Areas": "handyman",
+    "Security":     "locksmith+security",
+    "Noise":        "soundproofing+contractor",
 }
 
-def fiverr_url(category: str) -> str:
-    kw = FIVERR_KEYWORDS.get(category, "handyman+repair")
-    return f"https://www.fiverr.com/search/gigs?query={kw}"
-
-# ── Load data + models at startup ─────────────────────────────────────────────
+# ── Load data + models at startup ──────────────────────────────────────────────
 print("Downloading files from HF Hub...")
+
 csv_path    = hf_hub_download(repo_id=HF_REPO, filename="propertypilot_tickets.csv",
                               repo_type="dataset", token=HF_TOKEN)
 faiss_path  = hf_hub_download(repo_id=HF_REPO, filename="recommender/index.faiss",
@@ -101,6 +101,23 @@ df.reset_index(drop=True, inplace=True)
 df["urgency_code"] = df["urgency"].str[:2]
 print(f"Dataset: {len(df):,} rows")
 
+# Per-specialty contractor roster for ranking (see recommend_similar). Built
+# once at startup: contractor_specialty often disagrees with the category of
+# the ticket a contractor happens to have handled historically (67% of rows
+# in this dataset — likely a synthetic-generation artifact), so contractors
+# must be looked up by their own specialty, not by which tickets they appear
+# on, or the "recommended contractor" ends up being a specialist in a
+# different trade than the one the tenant's issue needs.
+_CONTRACTOR_COLS = ["contractor_id", "contractor_specialty", "contractor_success_rate",
+                    "contractor_avg_resolution_hours", "contractor_avg_cost"]
+_contractors = df[_CONTRACTOR_COLS].drop_duplicates("contractor_id")
+CONTRACTORS_BY_SPECIALTY = {
+    specialty: group.to_dict("records")
+    for specialty, group in _contractors.groupby("contractor_specialty")
+}
+print(f"Contractor roster: {len(_contractors)} contractors across "
+      f"{len(CONTRACTORS_BY_SPECIALTY)} specialties")
+
 with open(config_path) as f:
     cfg = json.load(f)
 
@@ -109,17 +126,76 @@ index       = faiss.read_index(faiss_path)
 embed_model = SentenceTransformer(cfg["model_name"])
 print(f"Embedder: {cfg['model_name']}  |  MIN_SIM={MIN_SIM}  |  {index.ntotal:,} vectors")
 
-print(f"Loading base model: {GEN_MODEL} + LoRA adapter: {LORA_REPO}...")
-gen_tokenizer = AutoTokenizer.from_pretrained(LORA_REPO, token=HF_TOKEN)
-gen_model     = AutoModelForCausalLM.from_pretrained(GEN_MODEL, torch_dtype=torch.float16)
-gen_model     = PeftModel.from_pretrained(gen_model, LORA_REPO, token=HF_TOKEN)
+print(f"Loading generation model: {GEN_MODEL}...")
+gen_tokenizer = AutoTokenizer.from_pretrained(GEN_MODEL)
+gen_model     = AutoModelForCausalLM.from_pretrained(GEN_MODEL, torch_dtype=torch.float32)
 gen_model.eval()
-print("Finetuned generation model ready.")
 
-# Quick Starters + autocomplete
+# ── Fine-tuned triage classifier (Bonus: two-head DistilBERT) ─────────────────
+# Independent cross-check against the retrieval-based triage below -- a model
+# actually trained on this dataset, not just nearest-neighbor lookup. Saved as
+# a state_dict only, so the exact architecture from the notebook (Fine-tuning
+# 4D) has to be redefined here to load it.
+print("Loading fine-tuned triage classifier...")
+TRIAGE_REPO = "propertypilot/property-pilot-triage"
+
+class TriageClassifier(nn.Module):
+    def __init__(self, n_categories, n_urgencies):
+        super().__init__()
+        self.bert     = DistilBertModel.from_pretrained("distilbert-base-uncased")
+        hidden        = self.bert.config.hidden_size
+        self.dropout  = nn.Dropout(0.2)
+        self.cat_head = nn.Linear(hidden, n_categories)
+        self.urg_head = nn.Linear(hidden, n_urgencies)
+
+    def forward(self, input_ids, attention_mask):
+        out = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        cls = self.dropout(out.last_hidden_state[:, 0])
+        return self.cat_head(cls), self.urg_head(cls)
+
+_triage_labels_path  = hf_hub_download(TRIAGE_REPO, "label_map.json")
+_triage_weights_path = hf_hub_download(TRIAGE_REPO, "model.pt")
+with open(_triage_labels_path) as f:
+    _triage_labels = json.load(f)
+TRIAGE_CATEGORIES = [_triage_labels["category_id2label"][str(i)]
+                     for i in range(len(_triage_labels["category_id2label"]))]
+TRIAGE_URGENCIES  = [_triage_labels["urgency_id2label"][str(i)]
+                     for i in range(len(_triage_labels["urgency_id2label"]))]
+
+triage_tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")
+triage_model = TriageClassifier(len(TRIAGE_CATEGORIES), len(TRIAGE_URGENCIES))
+triage_model.load_state_dict(torch.load(_triage_weights_path, map_location="cpu"))
+triage_model.eval()
+print(f"Triage classifier loaded: {len(TRIAGE_CATEGORIES)} categories, {len(TRIAGE_URGENCIES)} urgencies")
+
+
+def classify_triage(text):
+    """(category, urgency) prediction from the fine-tuned model -- this is the
+    primary triage signal shown to the user (test macro-F1: 0.975 category /
+    0.766 urgency). Retrieval's own top-neighbor category/urgency is shown
+    alongside as a cross-check, not the other way around, because a nearest-
+    neighbor vote can be pulled off course by a couple of superficially similar
+    but differently-severe historical tickets, while the classifier reads the
+    current message's own content directly."""
+    enc = triage_tokenizer(text, truncation=True, padding="max_length",
+                           max_length=128, return_tensors="pt")
+    with torch.no_grad():
+        cat_logits, urg_logits = triage_model(enc["input_ids"], enc["attention_mask"])
+    cat = TRIAGE_CATEGORIES[cat_logits.argmax(dim=1).item()]
+    urg = TRIAGE_URGENCIES[urg_logits.argmax(dim=1).item()]
+    return cat, urg
+
+
+print("Ready.")
+
+# ── Precomputed Quick Starters + autocomplete phrases (from the notebook) ─────
+# quick_starters: {category: {tenant_message, building_id, unit, work_order,
+#                              tenant_reply, ...}} — the LLM part is cached, so
+# clicking a Quick Starter never calls the generation model.
+# autocomplete_phrases: 40 representative (category, urgency) ticket texts used
+# to power the "suggestions while typing" row under the message box.
 QUICK_STARTERS_CACHE = {}
 AUTOCOMPLETE_PHRASES = []
-TEXT_TO_CACHED       = {}
 try:
     qs_path = hf_hub_download(repo_id=HF_REPO, filename="recommender/quick_starters_v2.json",
                               repo_type="dataset", token=HF_TOKEN)
@@ -127,17 +203,26 @@ try:
         _qs_data = json.load(f)
     QUICK_STARTERS_CACHE = _qs_data.get("quick_starters", {})
     AUTOCOMPLETE_PHRASES = _qs_data.get("autocomplete_phrases", [])
-    TEXT_TO_CACHED = {v["tenant_message"].strip(): v for v in QUICK_STARTERS_CACHE.values()}
-    print(f"Loaded {len(QUICK_STARTERS_CACHE)} Quick Starters, "
+    print(f"Loaded {len(QUICK_STARTERS_CACHE)} cached Quick Starters, "
           f"{len(AUTOCOMPLETE_PHRASES)} autocomplete phrases.")
 except Exception as e:
-    print(f"Could not load quick_starters_v2.json ({e}) — Quick Starters disabled.")
+    print(f"Could not load quick_starters_v2.json ({e}) — Quick Starters/autocomplete disabled.")
+
+# Exact-text lookup so pasting one of the 10 cached messages into the free-text
+# box (instead of clicking its button) is just as instant and deterministic.
+TEXT_TO_CACHED = {c["tenant_message"].strip(): c for c in QUICK_STARTERS_CACHE.values()}
+
+CATEGORY_ICON = {
+    "Plumbing": "🚰", "Electrical": "⚡", "HVAC": "🌡️", "Appliances": "🔌",
+    "Elevator": "🛗", "Structural": "🧱", "Pests": "🐜", "Common Areas": "🏢",
+    "Security": "🔒", "Noise": "🔊",
+}
 
-# ── Recommender (FAISS + BGE) ─────────────────────────────────────────────────
+
+# ── Recommender (Part 3: retrieval + contractor ranking) ──────────────────────
 def _encode(text):
-    prefix = cfg.get("query_prefix", "")
     return embed_model.encode(
-        [prefix + text],
+        [cfg["query_prefix"] + text],
         normalize_embeddings=True,
         convert_to_numpy=True,
     ).astype("float32")
@@ -146,12 +231,16 @@ def _encode(text):
 def recommend_similar(query_text, top_k=3, building_id=None):
     qvec = _encode(query_text)
     sims_r, idxs_r = index.search(qvec, top_k * 3 + 1)
+    # i < len(df) guards against the FAISS index and the dataset CSV having
+    # been updated out of step with each other (the index can point past the
+    # end of a since-shrunk dataset) — without this, a mismatch crashes every
+    # query whose nearest neighbors happen to land past the current row count.
     cand = [(float(s), int(i)) for s, i in zip(sims_r[0], idxs_r[0])
-            if i >= 0 and s >= MIN_SIM]
+            if 0 <= i < len(df) and s >= MIN_SIM]
     if not cand:
         return {"status": "no_match", "confidence": "low",
                 "message": "No similar ticket found above the similarity threshold.",
-                "similar_tickets": [], "contractor_rank": []}
+                "similar_tickets": [], "contractor_rank": [], "classifier_check": None}
     if building_id:
         same = [c for c in cand if df.iloc[c[1]]["building_id"] == building_id]
         rest = [c for c in cand if df.iloc[c[1]]["building_id"] != building_id]
@@ -163,8 +252,8 @@ def recommend_similar(query_text, top_k=3, building_id=None):
     for sim, i in cand:
         row = df.iloc[i]
         similar.append({
-            "similarity":       round(float(sim), 3),
-            "ticket_id":        str(row["ticket_id"]),
+            "similarity":       round(sim, 3),
+            "ticket_id":        row["ticket_id"],
             "category":         row["category"],
             "urgency":          row["urgency"],
             "tenant_tone":      row["tenant_tone"],
@@ -173,333 +262,479 @@ def recommend_similar(query_text, top_k=3, building_id=None):
             "cost_usd":         float(row["cost_usd"]),
             "contractor_id":    row["contractor_id"],
             "resolution_notes": row["resolution_notes"],
+            "building_id":      row["building_id"],
         })
 
-    counts = Counter(s["contractor_id"] for s in similar)
-    contractor_rank = [
-        {
-            "contractor_id": cid,
-            "count":         cnt,
-            "specialty":     next(s["category"] for s in similar if s["contractor_id"] == cid),
-            "reason":        f"Handled {cnt} of the top-{len(similar)} similar tickets",
-        }
-        for cid, cnt in counts.most_common()
+    top_cat   = Counter(t["category"] for t in similar).most_common(1)[0][0]
+    top_cat_n = Counter(t["category"] for t in similar)[top_cat]
+    confidence = "high" if top_cat_n == top_k else "medium" if top_cat_n > 1 else "low"
+
+    # Rank contractors who actually specialize in this ticket's category —
+    # NOT whichever contractor happened to be attached to a similar-worded
+    # historical ticket (contractor_specialty disagrees with that ticket's
+    # own category most of the time in this dataset, so that pool was often
+    # the wrong trade entirely). similar[0]["category"] matches the triage
+    # category shown in the UI (fmt_triage), so ranking stays consistent
+    # with what the tenant sees.
+    ticket_category = similar[0]["category"]
+    roster = CONTRACTORS_BY_SPECIALTY.get(ticket_category, [])
+    if not roster:
+        # No contractor lists this exact category as their specialty (not
+        # expected — every category has specialists in this dataset) — fall
+        # back to the old behavior rather than showing no contractor at all.
+        roster = [{"contractor_id": t["contractor_id"],
+                   "contractor_specialty": df.loc[df["contractor_id"] == t["contractor_id"],
+                                                   "contractor_specialty"].iloc[0],
+                   "contractor_success_rate": df.loc[df["contractor_id"] == t["contractor_id"],
+                                                      "contractor_success_rate"].iloc[0],
+                   "contractor_avg_resolution_hours": df.loc[df["contractor_id"] == t["contractor_id"],
+                                                              "contractor_avg_resolution_hours"].iloc[0],
+                   "contractor_avg_cost": df.loc[df["contractor_id"] == t["contractor_id"],
+                                                  "contractor_avg_cost"].iloc[0]}
+                  for t in {t["contractor_id"]: t for t in similar}.values()]
+
+    max_hours = max(r["contractor_avg_resolution_hours"] for r in roster) or 1
+    max_cost  = max(r["contractor_avg_cost"] for r in roster) or 1
+    contractor_rank = sorted(
+        [{"contractor_id": r["contractor_id"],
+          "specialty":    r["contractor_specialty"],
+          "success_rate": float(r["contractor_success_rate"]),
+          "avg_hours":    float(r["contractor_avg_resolution_hours"]),
+          "avg_cost":     float(r["contractor_avg_cost"]),
+          "score": (0.5 * float(r["contractor_success_rate"])
+                    - 0.3 * float(r["contractor_avg_resolution_hours"]) / max_hours
+                    - 0.2 * float(r["contractor_avg_cost"]) / max_cost),
+          "reason": (f"{r['contractor_specialty']} specialist — "
+                     f"success={r['contractor_success_rate']:.0%}, "
+                     f"avg {r['contractor_avg_resolution_hours']:.0f}h, "
+                     f"${r['contractor_avg_cost']:.0f}/job")}
+         for r in roster],
+        key=lambda x: -x["score"],
+    )[:5]
+
+    # Independent cross-check: the fine-tuned classifier predicts triage from
+    # the raw text alone, with no knowledge of the FAISS neighbors at all --
+    # agreement between two independently-derived triages is a much stronger
+    # confidence signal than either one alone.
+    cls_category, cls_urgency = classify_triage(query_text)
+    classifier_check = {
+        "category": cls_category,
+        "urgency": cls_urgency,
+        "agrees_category": cls_category == ticket_category,
+        "agrees_urgency": cls_urgency == similar[0]["urgency"][:2],
+    }
+
+    return {"status": "ok", "confidence": confidence,
+            "message": f"Top category: {top_cat} ({top_cat_n}/{top_k} neighbors agree)",
+            "similar_tickets": similar, "contractor_rank": contractor_rank,
+            "classifier_check": classifier_check}
+
+
+# ── LLM generation (Part 4: work order + tone-matched reply) ──────────────────
+def _generate_stream(prompt, max_new_tokens=500, temperature=0.6):
+    """Yields the growing generated text as tokens arrive, instead of blocking
+    until the full 500-token response is done. generate() runs in a background
+    thread (it's synchronous) while the main thread reads off the streamer —
+    the standard transformers pattern for streaming with .generate()."""
+    messages = [
+        {"role": "system", "content": "You are an assistant for a property management company."},
+        {"role": "user", "content": prompt},
     ]
+    text = gen_tokenizer.apply_chat_template(
+        messages, tokenize=False, add_generation_prompt=True
+    )
+    inputs = gen_tokenizer(text, return_tensors="pt")
+    streamer = TextIteratorStreamer(
+        gen_tokenizer, skip_prompt=True, skip_special_tokens=True
+    )
+    gen_kwargs = dict(
+        **inputs, max_new_tokens=max_new_tokens, temperature=temperature,
+        do_sample=True, top_p=0.9, repetition_penalty=1.1,
+        pad_token_id=gen_tokenizer.eos_token_id, streamer=streamer,
+    )
+    thread = Thread(target=_run_generate, args=(gen_kwargs, streamer))
+    thread.start()
+    partial = ""
+    try:
+        for chunk in streamer:
+            partial += chunk
+            yield partial
+    finally:
+        thread.join()
+    if not partial.strip():
+        yield "[Generation error — please try again.]"
 
-    top_sim   = cand[0][0]
-    confidence = "high" if top_sim > 0.85 else "medium" if top_sim > 0.70 else "low"
-    return {
-        "status":         "ok",
-        "confidence":     confidence,
-        "message":        f"Top similarity: {top_sim:.1%}",
-        "similar_tickets": similar,
-        "contractor_rank": contractor_rank,
-    }
 
-# ── LLM generation (Qwen2.5) ─────────────────────────────────────────────────
-@spaces.GPU
-def _generate(prompt, max_new_tokens=340, temperature=0.6):
+def _run_generate(gen_kwargs, streamer):
     try:
-        messages = [
-            {"role": "system", "content": "You are an assistant for a property management company."},
-            {"role": "user",   "content": prompt},
-        ]
-        text   = gen_tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-        inputs = gen_tokenizer(text, return_tensors="pt").to(gen_model.device)
         with torch.no_grad():
-            out = gen_model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                temperature=temperature,
-                do_sample=True,
-                top_p=0.9,
-                repetition_penalty=1.1,
-                pad_token_id=gen_tokenizer.eos_token_id,
-            )
-        new_tokens = out[0][inputs["input_ids"].shape[-1]:]
-        return gen_tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+            gen_model.generate(**gen_kwargs)
     except Exception as e:
-        return f"[Generation error: {e}]"
+        # generate() normally calls streamer.end() itself when it finishes;
+        # if it raises first that never happens, so the consumer thread would
+        # block forever on the queue. Close it here so the `for chunk in
+        # streamer` loop exits instead of hanging.
+        print(f"[Generation error: {e}]")
+        streamer.end()
+
+
+# A 0.5B model doesn't reliably reproduce the exact "WORK ORDER:" / "TENANT
+# REPLY:" strings from the prompt — in practice it also writes "WORK ORDER**"
+# (no colon), "TENANT RESPONSE", "REPLY TO TENANT", etc. The colon and the
+# exact word order were previously required, so any of those variants made
+# the split fail entirely and dumped the whole raw generation (including a
+# perfectly good tenant-facing message) into the work_order box.
+_WORK_ORDER_HEADER = re.compile(r"[\*\#\s]*work\s*order[\*\#\s]*:?[\*\#\s]*", re.IGNORECASE)
+_TENANT_REPLY_HEADER = re.compile(
+    r"[\*\#\s]*(?:tenant\s*(?:reply|response)|(?:reply|response)\s*to\s*tenant)[\*\#\s]*:?[\*\#\s]*",
+    re.IGNORECASE,
+)
+
+# Same intent as the notebook's Part 4 generation pipeline (_is_valid_generation
+# / BAD_PHRASES_GEN) — the deployed app never had this check at all, so a real
+# refusal like "I'm sorry, but I can't assist with this task." could reach the
+# tenant reply box unfiltered. But the notebook's original list banned bare
+# "i'm sorry" / "i apologize", which also matches completely legitimate,
+# non-refusal replies ("I'm sorry, but I don't have information about a
+# previous case, could you clarify?") -- measured a ~50% false-positive
+# discard rate on some queries because of this. Phrases below require an
+# actual refusal/inability statement, not just an apologetic opener.
+_BAD_PHRASES = ("i cannot assist", "i can't assist", "i can not assist",
+                "as an ai", "as a language model",
+                "i'm not able to help", "i am not able to help",
+                "i'm sorry, but i can", "i'm sorry but i can", "i'm sorry, i cannot",
+                "unable to fulfill", "unable to complete this request")
+
+# The model is occasionally handed its own instructions back as if they were
+# content -- e.g. it paraphrases the prompt's "Tenant tone: X -- Y" line
+# instead of writing an actual reply ("Reply Tone: Passive-Age -- the
+# tenant's tone is one of frustration...", or a trailing "Panic-Cap Tone\n\n
+# This reply should be extremely calm..."). This is a paraphrase, not a fixed
+# string, so there's no reliable place to cut it out and keep the rest --
+# treated as a failed generation (same bucket as a refusal) so the caller's
+# existing fallback substitution kicks in instead of leaking it to the user.
+_TONE_ECHO_PATTERNS = (
+    re.compile(r"^\s*(?:reply\s*tone|tenant\s*tone|tone)\s*:", re.IGNORECASE),
+    re.compile(r"\n\s*[A-Za-z][A-Za-z\- ]{2,30}\btone\b\s*\n", re.IGNORECASE),
+    re.compile(r"the tenant'?s tone (?:is|remains|was)\b", re.IGNORECASE),
+    re.compile(r"this reply should be\b", re.IGNORECASE),
+)
+
+
+def _has_tone_echo(text):
+    return any(p.search(text) for p in _TONE_ECHO_PATTERNS)
+
 
+def _is_valid_generation(text):
+    if not text or len(text) < 15:
+        return False
+    if any(p in text.lower() for p in _BAD_PHRASES):
+        return False
+    return not _has_tone_echo(text)
 
-_WO_HDR = re.compile(r"[\*\#\s]*work order[\*\#\s]*:[\*\#\s]*", re.IGNORECASE)
-_TR_HDR = re.compile(r"[\*\#\s]*tenant reply[\*\#\s]*:[\*\#\s]*", re.IGNORECASE)
 
+_MD_BOLD   = re.compile(r"\*\*(.+?)\*\*")
+_MD_ITALIC = re.compile(r"(?<!\*)\*(?!\*)([^*\n]+?)\*(?!\*)")
 
-def _clean(text):
+# The model sometimes keeps generating past the first TENANT REPLY section and
+# hallucinates a second WORK ORDER / TENANT REPLY / TICKET DETAILS round
+# (occasionally numbered, "Work Order #2") -- unlike the tone-echo leak above,
+# this one has an unambiguous, fixed marker, so it's safe to just cut there.
+_SECOND_ROUND_HEADER = re.compile(
+    r"\n[\*\#\s]*(?:work\s*order(?:\s*#\s*\d+)?|tenant\s*(?:reply|response)|ticket\s*details)[\*\#\s]*:?",
+    re.IGNORECASE,
+)
+
+# A trailing sign-off line that's *only* a bracket placeholder ("[Your Name]",
+# "[Your Position]") is never legitimate content -- safe to drop outright,
+# unlike an inline placeholder ("Dear [Tenant's Name],") where removing just
+# the bracket would leave an awkward gap.
+_PLACEHOLDER_LINE = re.compile(r"^\s*\[[^\]]{2,40}\]\s*$", re.MULTILINE)
+
+# The model is handed the real priority/SLA in its prompt but sometimes
+# paraphrases -- or outright hallucinates -- its own version inside the WORK
+# ORDER section it generates, contradicting the Triage card above it (which
+# always shows the fine-tuned classifier's real value). Strip whatever the
+# model wrote and replace it with the authoritative line so the two can never
+# disagree.
+_PRIORITY_LINE = re.compile(r"^\s*-?\s*Priority:.*$", re.MULTILINE | re.IGNORECASE)
+
+
+def _inject_authoritative_priority(work_order, urgency, sla):
+    if not work_order:
+        return work_order
+    stripped = _PRIORITY_LINE.sub("", work_order).strip()
+    header = f"Priority: {urgency} | SLA: {sla}"
+    return f"{header}\n{stripped}" if stripped else header
+
+
+def _truncate_second_round(text):
+    m = _SECOND_ROUND_HEADER.search(text)
+    return text[:m.start()].rstrip() if m else text
+
+
+def _clean_section(text):
+    """Strip markdown artifacts the model leaves in -- both at the edges (left
+    over from splitting on a header) and scattered through the middle (e.g.
+    '**To:** [Tenant's Name]'), since these render in a plain gr.Textbox, not
+    as markdown, so unstripped ** show up literally in the UI."""
+    text = _truncate_second_round(text)
+    text = _MD_BOLD.sub(r"\1", text)
+    text = _MD_ITALIC.sub(r"\1", text)
+    text = re.sub(r"^\s*#+\s*", "", text, flags=re.MULTILINE)
+    text = re.sub(r"^\s*-{3,}\s*$", "", text, flags=re.MULTILINE)
+    text = _PLACEHOLDER_LINE.sub("", text)
+    # Orphaned ** can survive the paired substitution above -- e.g. the header
+    # regex's own trailing [\*\#\s]* sometimes swallows the opening ** of the
+    # very next bold run, stranding its closing **. Anything left at this
+    # point isn't a valid pair, so it's safe to drop outright.
+    text = text.replace("**", "")
     return text.strip().strip("*#").strip()
 
 
-def _split_wo_reply(raw):
-    wo_m = _WO_HDR.search(raw)
-    tr_m = _TR_HDR.search(raw)
-    if wo_m and tr_m and tr_m.start() > wo_m.start():
-        wo = _clean(raw[wo_m.end():tr_m.start()])
-        tr = _clean(raw[tr_m.end():])
-    elif tr_m:
-        wo = _clean(raw[:tr_m.start()])
-        tr = _clean(raw[tr_m.end():])
+def _split_work_order_reply_partial(raw_text):
+    """Header-based split of one combined generation into (work_order,
+    tenant_reply), tolerant of a still-streaming partial text: never
+    substitutes the 'Manual review required' / 'Thank you for reporting'
+    fallback text here, since an empty section usually just hasn't been
+    generated yet rather than having failed (the caller applies fallbacks —
+    and refusal detection — once streaming is done)."""
+    wo_match = _WORK_ORDER_HEADER.search(raw_text)
+    tr_match = _TENANT_REPLY_HEADER.search(raw_text)
+
+    if wo_match and tr_match and tr_match.start() > wo_match.start():
+        work_order   = _clean_section(raw_text[wo_match.end():tr_match.start()])
+        tenant_reply = _clean_section(raw_text[tr_match.end():])
+    elif tr_match:
+        work_order   = _clean_section(raw_text[:tr_match.start()])
+        tenant_reply = _clean_section(raw_text[tr_match.end():])
+    elif wo_match:
+        work_order   = _clean_section(raw_text[wo_match.end():])
+        tenant_reply = ""
     else:
-        wo = _clean(raw)
-        tr = ""
-    wo = wo or "Manual review required — auto-generation was inconclusive."
-    tr = tr or "Thank you for reporting this — a technician has been assigned."
-    return wo, tr
-
-
-def generate_ticket_response(tenant_message, category, urgency, tenant_tone,
-                             building_id, unit, similar_tickets=None, contractor=None):
-    sla              = SLA_MAP.get(urgency[:2], "TBD")
-    tone_instruction = TONE_INSTRUCTIONS.get(tenant_tone, TONE_INSTRUCTIONS["polite-formal"])
-    past_case        = ""
+        work_order   = _clean_section(raw_text)
+        tenant_reply = ""
+    return work_order, tenant_reply
+
+
+def generate_ticket_response_stream(tenant_message, category, urgency, tenant_tone,
+                                    building_id, unit, similar_tickets=None, contractor=None):
+    """Same single-call prompt as before (still the main per-request latency
+    reduction versus two sequential calls) — but now yields (work_order,
+    tenant_reply) as the model streams, instead of blocking until all 340
+    tokens are done."""
+    sla = SLA_MAP.get(urgency[:2], "TBD")
+    tone_instruction = TONE_INSTRUCTIONS.get(tenant_tone, "Be professional, warm, and helpful.")
+
+    past_case = ""
     if similar_tickets:
         t = similar_tickets[0]
-        past_case = (f"- Similar past case: {t['raw_text'][:120]}... "
-                     f"(resolved in {t['resolution_hours']:.0f}h, ${t['cost_usd']:.0f})\n")
-    contractor_info = (
-        f"- Suggested contractor: {contractor['contractor_id']} ({contractor['specialty']})\n"
-        if contractor else ""
-    )
+        past_case = (f"Most similar past case: {t['category']} resolved in "
+                     f"{t['resolution_hours']:.0f}h for ${t['cost_usd']:.0f}. "
+                     f"Notes: {t['resolution_notes']}\n")
+    contractor_info = ""
+    if contractor:
+        contractor_info = (f"Assigned contractor: {contractor['contractor_id']} "
+                           f"(specialty: {contractor['specialty']}, "
+                           f"avg {contractor['avg_hours']:.0f}h, "
+                           f"success {contractor['success_rate']:.0%})\n")
+
     prompt = (
-        "Produce exactly two labeled sections (no markdown on the headers themselves):\n\n"
+        "You are an assistant for a property management company. Given the ticket "
+        "details below, produce exactly two labeled sections and nothing else — no "
+        "markdown formatting on the section headers themselves, plain text after "
+        "each header:\n\n"
         "WORK ORDER:\n"
-        "<professional work order: issue description, priority/SLA, 2-3 action steps>\n\n"
+        "<a professional work order for the contractor, covering: (1) a clear issue "
+        "description, (2) priority level and SLA deadline, (3) 2-3 specific numbered "
+        "action instructions, (4) relevant context from the similar past case below "
+        "if any>\n\n"
         "TENANT REPLY:\n"
-        "<2-4 sentence reply to tenant, matching tone; no internal IDs or contractor names>\n\n"
-        f"DETAILS:\n"
+        "<a 2-4 sentence reply to the tenant, matching the tone guidance below; "
+        "do NOT mention internal systems, ticket IDs, or contractor names>\n\n"
+        f"TICKET DETAILS:\n"
         f"- Building: {building_id}, Unit: {unit}\n"
         f"- Category: {category}\n"
-        f"- Priority: {urgency} (SLA: {sla})\n"
+        f"- Priority: {urgency} (SLA: respond within {sla})\n"
         f"- Tenant report: {tenant_message}\n"
-        f"- Tone: {tenant_tone} — {tone_instruction}\n"
+        f"- Tenant tone: {tenant_tone} — {tone_instruction}\n"
         f"{past_case}{contractor_info}"
     )
-    raw = _generate(prompt)
-    return _split_wo_reply(raw)
-
-# ── Full pipeline ─────────────────────────────────────────────────────────────
-def run_pipeline(tenant_message, building_id="", unit="N/A"):
+    # One call instead of two (the Round-1 speed fix) — but still enough tokens
+    # for real structured detail, not just a couple of terse sentences.
+    work_order, tenant_reply = "", ""
+    for partial in _generate_stream(prompt, max_new_tokens=340, temperature=0.6):
+        work_order, tenant_reply = _split_work_order_reply_partial(partial)
+        work_order = _inject_authoritative_priority(work_order, urgency, sla)
+        yield work_order, tenant_reply
+    # Final pass — same fallback text as before, now also triggered by a
+    # refusal/garbage generation (_is_valid_generation), not just an empty
+    # section. Only applied once streaming is done, so a legitimate answer
+    # isn't discarded mid-stream just because it's still short.
+    if not _is_valid_generation(work_order):
+        work_order = "Manual review required — auto-generation was inconclusive."
+    if not _is_valid_generation(tenant_reply):
+        tenant_reply = "Thank you for reporting this — a technician has been assigned."
+    yield work_order, tenant_reply
+
+
+# ── Full pipeline: USER INPUT -> retrieval -> triage -> generation ────────────
+def run_pipeline_stream(tenant_message, building_id="", unit="N/A"):
+    """Generator version of the old run_pipeline: yields a growing result dict
+    as generation streams in, with generating=True until the final yield. The
+    no_match case now short-circuits before ever calling the LLM (previously
+    the full 340-token generation ran and was simply discarded by the caller
+    for a message that didn't match anything)."""
     building_id = building_id.strip() or None
     unit        = unit.strip() or "N/A"
-    rec         = recommend_similar(tenant_message, top_k=3, building_id=building_id)
-    similar     = rec["similar_tickets"]
-    contractor  = rec["contractor_rank"][0] if rec["contractor_rank"] else None
-    category    = similar[0]["category"]    if similar else "Unknown"
-    urgency     = similar[0]["urgency"]     if similar else "P3 Standard (3-5d)"
-    tone        = similar[0]["tenant_tone"] if similar else "polite-formal"
-    work_order, tenant_reply = generate_ticket_response(
-        tenant_message, category, urgency, tone,
-        building_id or "Unknown", unit, similar, contractor,
-    )
-    return {
-        "triage":          {"category": category, "urgency": urgency, "tone": tone},
-        "retrieval":       rec,
-        "contractor":      contractor,
-        "work_order":      work_order,
-        "tenant_reply":    tenant_reply,
-        "tenant_message":  tenant_message,
-        "building_id":     building_id or "Unknown",
-        "unit":            unit,
-    }
-
-# ── HTML timeline rendering ───────────────────────────────────────────────────
-def esc(s) -> str:
-    return html.escape(str(s or ""))
-
-
-_EMPTY_TIMELINE = (
-    '<div class="pp-timeline">'
-    '<p class="pp-empty-state">Paste a tenant message and hit Analyze.</p>'
-    '</div>'
-)
-
-
-def _render_timeline(result):
-    t          = result["triage"]
-    category   = t["category"]
-    urgency    = t["urgency"]
-    tone       = t["tone"]
-    similar    = result["retrieval"]["similar_tickets"]
-    contractor = result.get("contractor")
-    building   = result["building_id"]
-    unit       = result["unit"]
-    text       = result["tenant_message"]
-
-    code      = urgency[:2]
-    bg, fg, border = URGENCY_STYLE.get(code, URGENCY_STYLE["P3"])
-    icon      = CATEGORY_ICONS.get(category, "📋")
-    sla       = SLA_MAP.get(code, "TBD")
-    urg_emoji = URGENCY_EMOJI.get(code, "")
-
-    conf_label = {"high": "✅ High", "medium": "⚠️ Medium", "low": "❓ Low"}.get(
-        result["retrieval"]["confidence"], result["retrieval"]["confidence"]
-    )
-
-    # Similar tickets rows
-    sim_rows = "".join(
-        f'<div class="pp-sim-row">'
-        f'<span class="pp-sim-id">{esc(s["ticket_id"])}</span>'
-        f'<span class="pp-sim-text">{esc(s["raw_text"][:110])}…</span>'
-        f'<span class="pp-sim-score">{s["similarity"]:.0%}</span>'
-        f'</div>'
-        for s in similar
-    ) or '<div class="pp-sim-row pp-empty">No close matches found.</div>'
-
-    contractor_html = ""
-    if contractor:
-        contractor_html = (
-            f'<div class="pp-contractor">'
-            f'🏗️ Recommended: <b>{esc(contractor["contractor_id"])}</b> '
-            f'({esc(contractor["specialty"])}) — {esc(contractor["reason"])}'
-            f'</div>'
-        )
-
-    flink = fiverr_url(category)
-    fiverr_html = (
-        f'<a href="{esc(flink)}" target="_blank" rel="noopener" class="pp-fiverr-btn">'
-        f'🔗 Find a {esc(category)} contractor on Fiverr</a>'
-    )
-
-    return f"""
-<div class="pp-timeline">
-  <div class="pp-bubble">
-    <span class="pp-bubble-meta">{esc(building)} / {esc(unit)}</span>
-    <p>{esc(text)}</p>
-  </div>
-
-  <div class="pp-node">
-    <span class="pp-dot" style="background:{fg}"></span>
-    <div class="pp-card">
-      <p class="pp-card-label" style="color:{fg}">Triage</p>
-      <span class="pp-badge" style="background:{bg};color:{fg};border:1px solid {border}">{icon} {esc(category)}</span>
-      <span class="pp-badge" style="background:{bg};color:{fg};border:1px solid {border}">{urg_emoji} Priority {code}</span>
-      <span class="pp-badge" style="background:{bg};color:{fg};border:1px solid {border}">SLA: {sla}</span>
-      <p style="font-size:12px;margin-top:8px;color:#9a9ba0">
-        Tone: <code style="color:{fg}">{esc(tone)}</code> &nbsp;·&nbsp;
-        Confidence: {conf_label}
-      </p>
-      <div style="margin-top:12px">{fiverr_html}</div>
-    </div>
-  </div>
-
-  <div class="pp-node">
-    <span class="pp-dot pp-dot-purple"></span>
-    <div class="pp-card">
-      <p class="pp-card-label pp-label-purple">Similar past tickets</p>
-      {sim_rows}
-      {contractor_html}
-    </div>
-  </div>
-</div>
-"""
-
-
-def _render_result_cards(work_order, reply):
-    return f"""
-<div class="pp-node pp-node-last">
-  <span class="pp-dot pp-dot-pink"></span>
-  <div class="pp-card">
-    <p class="pp-card-label pp-label-pink">Work order</p>
-    <pre class="pp-pre">{esc(work_order)}</pre>
-    <p class="pp-card-label pp-label-pink" style="margin-top:10px">Tenant reply</p>
-    <pre class="pp-pre">{esc(reply)}</pre>
-  </div>
-</div>
-"""
-
-
-def _result_to_outputs(result):
-    timeline = _render_timeline(result) + _render_result_cards(
-        result["work_order"], result["tenant_reply"]
-    )
-    triage_lbl = f"{result['triage']['category']} · {result['triage']['urgency'][:2]}"
-    result_json = json.dumps(result, default=str)
-    return timeline, result["work_order"], result["tenant_reply"], triage_lbl, result_json
-
-# ── Cache helpers ─────────────────────────────────────────────────────────────
-def _render_from_cache(tenant_message, building_id, unit, cached, status_msg):
     rec        = recommend_similar(tenant_message, top_k=3, building_id=building_id)
     similar    = rec["similar_tickets"]
     contractor = rec["contractor_rank"][0] if rec["contractor_rank"] else None
-    cat  = similar[0]["category"]    if similar else "Unknown"
-    urg  = similar[0]["urgency"]     if similar else "P3 Standard (3-5d)"
-    tone = similar[0]["tenant_tone"] if similar else "polite-formal"
-    result = {
-        "triage":         {"category": cat, "urgency": urg, "tone": tone},
+    # Primary triage signal is the fine-tuned classifier (test macro-F1: 0.975
+    # category / 0.766 urgency) -- it reads the current message's own content
+    # directly, rather than voting across nearest historical neighbors, which
+    # matters most for urgency: a couple of superficially similar but
+    # differently-severe past tickets can otherwise pull retrieval's vote
+    # toward the wrong SLA for a genuine emergency. Retrieval's own top-neighbor
+    # category/urgency is still shown as a cross-check (see fmt_triage below).
+    cc = rec.get("classifier_check")
+    if cc:
+        category = cc["category"]
+        urgency  = URGENCY_FULL.get(cc["urgency"], cc["urgency"])
+    else:
+        category = similar[0]["category"] if similar else "Unknown"
+        urgency  = similar[0]["urgency"]  if similar else "P3 Standard (3-5d)"
+    tone       = similar[0]["tenant_tone"] if similar else "polite-formal"
+
+    base = {
+        "triage":         {"category": category, "urgency": urgency, "tone": tone},
         "retrieval":      rec,
         "contractor":     contractor,
-        "work_order":     cached.get("work_order", ""),
-        "tenant_reply":   cached.get("tenant_reply", ""),
         "tenant_message": tenant_message,
-        "building_id":    building_id,
+        "building_id":    building_id or "Unknown",
         "unit":           unit,
     }
-    tl, wo, rp, lbl, rj = _result_to_outputs(result)
-    return tl, wo, rp, lbl, status_msg, rj
 
+    if rec["status"] == "no_match":
+        yield {**base, "work_order": "", "tenant_reply": "", "generating": False}
+        return
 
-def use_cached_quick_starter(category):
-    cached = QUICK_STARTERS_CACHE.get(category)
-    if not cached:
-        return ("", "B-01", "1A", _EMPTY_TIMELINE, "", "", "", "Quick Starter not available.", None)
-    tm  = cached["tenant_message"]
-    bid = cached.get("building_id", "B-01")
-    u   = cached.get("unit", "1A")
-    tl, wo, rp, lbl, status, rj = _render_from_cache(tm, bid, u, cached, "Loaded from cache — instant!")
-    return tm, bid, u, tl, wo, rp, lbl, status, rj
-
-# ── Gradio process function ───────────────────────────────────────────────────
-def process(tenant_message, building_id, unit):
-    if not tenant_message or not tenant_message.strip():
-        return _EMPTY_TIMELINE, "", "", "", "Please enter a tenant message.", None
+    # First yield: retrieval/triage already computed (a few ms), generation
+    # not started yet — the UI can show Triage + Similar Tickets immediately.
+    yield {**base, "work_order": "", "tenant_reply": "", "generating": True}
 
-    cached = TEXT_TO_CACHED.get(tenant_message.strip())
-    if cached:
-        bid = building_id.strip() or cached.get("building_id", "B-01")
-        u   = unit.strip() or cached.get("unit", "1A")
-        tl, wo, rp, lbl, status, rj = _render_from_cache(
-            tenant_message.strip(), bid, u, cached, "Matched a known ticket — instant cached result!"
+    work_order, tenant_reply = "", ""
+    for work_order, tenant_reply in generate_ticket_response_stream(
+        tenant_message, category, urgency, tone,
+        building_id or "Unknown", unit, similar, contractor,
+    ):
+        yield {**base, "work_order": work_order, "tenant_reply": tenant_reply, "generating": True}
+
+    yield {**base, "work_order": work_order, "tenant_reply": tenant_reply, "generating": False}
+
+
+# ── Format helpers ─────────────────────────────────────────────────────────────
+def fmt_triage(result):
+    t    = result["triage"]
+    r    = result["retrieval"]
+    code = t["urgency"][:2]
+    sla  = SLA_MAP.get(code, "TBD")
+    color = URGENCY_HEX.get(code, "#6b7280")
+    conf = {"high": "✅ High", "medium": "⚠️ Medium", "low": "❓ Low"}.get(
+        r["confidence"], r["confidence"])
+
+    # States both signals as peers rather than "X agrees/disagrees with the
+    # headline above" -- this same formatter is also used by the cached Quick
+    # Starter path, where the headline is retrieval's pick rather than the
+    # classifier's, so the line must read correctly either way.
+    cc = r.get("classifier_check")
+    similar = r.get("similar_tickets") or []
+    if cc and similar:
+        retr_cat = similar[0]["category"]
+        retr_urg = similar[0]["urgency"][:2]
+        match_icon = "✅" if (cc["agrees_category"] and cc["agrees_urgency"]) else "⚠️"
+        retr_line = (f"**🤖 Fine-tuned classifier:** {cc['category']} · {cc['urgency']}"
+                     f"&nbsp;&nbsp;|&nbsp;&nbsp;**📋 Nearest neighbors:** {retr_cat} · {retr_urg} {match_icon}")
+    else:
+        retr_line = "**🤖 Fine-tuned classifier:** _unavailable_"
+
+    pill = (
+        f'<div class="pp-priority-pill" style="background:{color}22; border:1.5px solid {color}; color:{color};">'
+        f"{URGENCY_EMOJI.get(code, '')} {t['category']} · {code} · SLA {sla}</div>"
+    )
+
+    return (
+        f'<div style="border-left:4px solid {color}; padding-left:12px;">\n\n'
+        f"{pill}\n\n"
+        f"**Tenant tone detected:** `{t['tone']}`\n\n"
+        f"**Retrieval confidence:** {conf} — {r['message']}\n\n"
+        f"{retr_line}"
+        f"\n\n</div>"
+    )
+
+
+def fmt_similar(result):
+    similar = result["retrieval"]["similar_tickets"]
+    if not similar:
+        return f"_No similar tickets found above the {MIN_SIM} similarity threshold._"
+    lines = []
+    for i, t in enumerate(similar, 1):
+        code  = t["urgency"][:2]
+        color = URGENCY_HEX.get(code, "#6b7280")
+        pct   = t["similarity"] * 100
+        bar   = (f'<div class="pp-match-bar"><div class="pp-match-bar-fill" '
+                 f'style="background:{color};width:{pct:.0f}%;"></div></div>')
+        lines.append(
+            f'<div style="border-left:3px solid {color}; padding-left:10px; margin-bottom:6px;">\n\n'
+            f"**[{i}] {t['similarity']:.1%} match**  |  {t['category']}  |  {code}\n{bar}\n"
+            f"> {t['raw_text'][:130]}...\n"
+            f"Resolved in **{t['resolution_hours']:.0f}h** · "
+            f"**${t['cost_usd']:.0f}** · _{t['resolution_notes']}_"
+            f"\n\n</div>"
         )
-        return tl, wo, rp, lbl, status, rj
-
-    result = run_pipeline(tenant_message, building_id, unit)
-    if result["retrieval"]["status"] == "no_match":
-        return (
-            '<div class="pp-timeline"><p class="pp-empty-state">'
-            "⚠️ Input doesn't resemble a maintenance request.</p></div>",
-            "", "", "",
-            "⚠️ Not recognized as a maintenance request — please describe a specific issue.",
-            None,
+    c = result.get("contractor")
+    if c:
+        lines.append(
+            f"\n---\n**Recommended contractor:** {c['contractor_id']}  "
+            f"({c['specialty']})  |  {c['reason']}"
         )
-    tl, wo, rp, lbl, rj = _result_to_outputs(result)
-    return tl, wo, rp, lbl, "Done!", rj
-
+    return "\n\n".join(lines)
+
+
+def fmt_yelp_link(result):
+    if not result:
+        return ""
+    cat = result["triage"]["category"]
+    keyword = YELP_KEYWORDS.get(cat, "handyman")
+    url = f"https://www.yelp.com/search?find_desc={keyword}&find_loc=New+York%2C+NY"
+    return (
+        f'🔍 **Find a real contractor on Yelp:** '
+        f'[Search {cat} contractors in New York City →]({url})'
+    )
 
-def clear_all():
-    return ("", "B-01", "1A", _EMPTY_TIMELINE, "", "", "", "", None)
 
-# ── Slack ─────────────────────────────────────────────────────────────────────
+# ── Slack dispatch (+5% chatapp bonus) ─────────────────────────────────────────
 def send_to_slack(result_json):
     if not result_json:
         return "Run the pipeline first."
     if not SLACK_WEBHOOK:
-        return "Slack not configured — add SLACK_WEBHOOK_URL to Space secrets."
+        return "Slack not configured — add a SLACK_WEBHOOK_URL secret in Space settings."
     result = json.loads(result_json) if isinstance(result_json, str) else result_json
     code   = result["triage"]["urgency"][:2]
     c      = result.get("contractor")
-    con_text  = f"{c['contractor_id']} ({c['specialty']}) — {c['reason']}" if c else "N/A"
+    con_text = f"{c['contractor_id']} ({c['specialty']}) — {c['reason']}" if c else "N/A"
     sim_lines = "\n".join(
         f"[{t['similarity']:.2f}] {t['category']} — {t['raw_text'][:70]}..."
         for t in result["retrieval"]["similar_tickets"][:3]
     ) or "None"
     payload = {"attachments": [{
         "color": URGENCY_HEX.get(code, "#7289DA"),
-        "title": f"PropertyPilot — New Ticket  {URGENCY_EMOJI.get(code,'')} {code}",
+        "title": f"PropertyPilot — New Maintenance Ticket  {URGENCY_EMOJI.get(code, '')} {code}",
         "fields": [
-            {"title": "Location",        "value": f"Building {result['building_id']} | Unit {result['unit']}", "short": True},
-            {"title": "Category",        "value": result["triage"]["category"], "short": True},
-            {"title": "Tone",            "value": result["triage"]["tone"],     "short": True},
-            {"title": "SLA",             "value": SLA_MAP.get(code, "TBD"),     "short": True},
+            {"title": "Location", "value": f"Building {result['building_id']} | Unit {result['unit']}", "short": True},
+            {"title": "Category", "value": result["triage"]["category"], "short": True},
+            {"title": "Tone",     "value": result["triage"]["tone"],     "short": True},
+            {"title": "SLA",      "value": SLA_MAP.get(code, "TBD"),     "short": True},
             {"title": "Tenant Message",  "value": result["tenant_message"][:300]},
             {"title": "Similar Tickets", "value": sim_lines},
             {"title": "Contractor",      "value": con_text},
@@ -509,22 +744,36 @@ def send_to_slack(result_json):
     }]}
     try:
         r = requests.post(SLACK_WEBHOOK, json=payload, timeout=10)
-        return "Dispatched to Slack ops channel!" if r.status_code == 200 else f"Slack error {r.status_code}: {r.text[:200]}"
+        if r.status_code == 200:
+            return "Dispatched to Slack ops channel!"
+        return f"Slack error {r.status_code}: {r.text[:200]}"
     except Exception as e:
         return f"Request failed: {e}"
 
-# ── NYC-311 live feed ─────────────────────────────────────────────────────────
-_NYC311_TYPES = (
+
+
+# ── NYC-311 live feed (+5% live-data bonus) ────────────────────────────────────
+NYC311_TYPES = (
     "'HEAT/HOT WATER','PLUMBING','ELECTRIC','ELEVATOR',"
     "'PAINT/PLASTER','WATER LEAK','DOOR/WINDOW','FLOORING/STAIRS'"
 )
 
 
+STATUS_COLOR = {"open": "#f59e0b", "closed": "#22c55e", "in progress": "#3b82f6",
+                 "pending": "#f59e0b", "assigned": "#3b82f6"}
+
+
+def _status_badge(s):
+    color = STATUS_COLOR.get((s or "").strip().lower(), "#6b7280")
+    return (f'<span style="background:{color}22;color:{color};padding:2px 10px;'
+            f'border-radius:999px;font-weight:600;">{s}</span>')
+
+
 def fetch_nyc311():
     url = (
         "https://data.cityofnewyork.us/resource/erm2-nwe9.json"
         f"?$limit=25&$order=created_date+DESC"
-        f"&$where=complaint_type+IN+({_NYC311_TYPES})"
+        f"&$where=complaint_type+IN+({NYC311_TYPES})"
     )
     fetched_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
     try:
@@ -536,49 +785,78 @@ def fetch_nyc311():
             "Borough":      d.get("borough", "-").title(),
             "Complaint":    d.get("complaint_type", ""),
             "Detail":       d.get("descriptor", ""),
-            "Status":       d.get("status", ""),
+            "Status":       _status_badge(d.get("status", "")),
+            # NYC's own timestamp for when the complaint's status last changed —
+            # distinct from "Reported", so you can see which cases are actively moving.
             "Last Updated": (d.get("resolution_action_updated_date")
                              or d.get("created_date", ""))[:16].replace("T", " "),
         } for d in data]
-        return pd.DataFrame(rows), f"Loaded {len(rows)} complaints · refreshed {fetched_at}"
+        status = f"Loaded {len(rows)} recent maintenance complaints · feed refreshed {fetched_at}"
+        return pd.DataFrame(rows), status
     except Exception as e:
         empty = pd.DataFrame(columns=["Reported", "Borough", "Complaint", "Detail", "Status", "Last Updated"])
-        return empty, f"Error: {e} · {fetched_at}"
+        return empty, f"Error: {e} · last attempted {fetched_at}"
 
 
-def process_311_row(row_index):
-    url = (
-        "https://data.cityofnewyork.us/resource/erm2-nwe9.json"
-        f"?$limit=25&$order=created_date+DESC"
-        f"&$where=complaint_type+IN+({_NYC311_TYPES})"
+# ── Quick Starters — instant, cached (no model calls) ─────────────────────────
+def _render_from_cache(tenant_message, building_id, unit, cached, status_msg):
+    """Shared by the Quick Starter buttons and the exact-text match in process():
+    retrieval is recomputed live (FAISS search only, no LLM — a few ms) so the
+    Similar Tickets / Triage panels are built the normal way; the cached
+    work_order/tenant_reply (the expensive LLM part) are reused as-is, which is
+    what makes this instant and deterministic no matter how the text arrived."""
+    rec        = recommend_similar(tenant_message, top_k=3, building_id=building_id)
+    similar    = rec["similar_tickets"]
+    contractor = rec["contractor_rank"][0] if rec["contractor_rank"] else None
+    cat  = similar[0]["category"]    if similar else "Unknown"
+    urg  = similar[0]["urgency"]     if similar else "P3 Standard (3-5d)"
+    tone = similar[0]["tenant_tone"] if similar else "polite-formal"
+
+    result = {
+        "triage":         {"category": cat, "urgency": urg, "tone": tone},
+        "retrieval":      rec,
+        "contractor":     contractor,
+        "work_order":     cached.get("work_order", ""),
+        "tenant_reply":   cached.get("tenant_reply", ""),
+        "tenant_message": tenant_message,
+        "building_id":    building_id,
+        "unit":           unit,
+    }
+    result_json = json.dumps(result, default=str)
+    return (fmt_triage(result), fmt_similar(result),
+            result["work_order"], result["tenant_reply"],
+            status_msg, result_json, fmt_yelp_link(result))
+
+
+def use_cached_quick_starter(category):
+    """Quick Starter button handler — also fills msg/building/unit for transparency."""
+    cached = QUICK_STARTERS_CACHE.get(category)
+    if not cached:
+        return ("", "", "", "", "", "", "", "Quick Starter not available.", None, "")
+
+    tenant_message = cached["tenant_message"]
+    building_id    = cached["building_id"]
+    unit           = cached["unit"]
+    triage_md, similar_md, work_order, tenant_reply, status, result_json, yelp = _render_from_cache(
+        tenant_message, building_id, unit, cached, "Loaded from cache — instant!"
     )
-    try:
-        r    = requests.get(url, timeout=15)
-        r.raise_for_status()
-        data = r.json()
-        idx  = int(row_index) if row_index is not None else 0
-        idx  = max(0, min(idx, len(data) - 1))
-        row  = data[idx]
-        text = (f"{row.get('complaint_type','')}: {row.get('descriptor','')} "
-                f"at {row.get('incident_address','')}")
-        return process(text, row.get("incident_address", "NYC")[:20], "311")
-    except Exception as e:
-        return _EMPTY_TIMELINE, "", "", "", f"Error fetching 311 data: {e}", None
+    return (tenant_message, building_id, unit,
+            triage_md, similar_md, work_order, tenant_reply, status, result_json, yelp)
 
-# ── Autocomplete ──────────────────────────────────────────────────────────────
-N_SUGGESTIONS = 5
 
+# ── Autocomplete suggestions while typing ─────────────────────────────────────
+N_SUGGESTIONS = 5
 
 def get_suggestions(text):
     text = (text or "").strip()
     if not text or not AUTOCOMPLETE_PHRASES:
         return [gr.update(value="", visible=False) for _ in range(N_SUGGESTIONS)] + [[]]
-    t        = text.lower()
-    starts   = [p for p in AUTOCOMPLETE_PHRASES if p.lower().startswith(t)]
+    t = text.lower()
+    starts  = [p for p in AUTOCOMPLETE_PHRASES if p.lower().startswith(t)]
     contains = [p for p in AUTOCOMPLETE_PHRASES if t in p.lower() and p not in starts]
-    matches  = (starts + contains)[:N_SUGGESTIONS]
-    labels   = [(m[:55] + "...") if len(m) > 55 else m for m in matches]
-    updates  = [
+    matches = (starts + contains)[:N_SUGGESTIONS]
+    labels  = [(m[:55] + "...") if len(m) > 55 else m for m in matches]
+    updates = [
         gr.update(value=labels[i], visible=True) if i < len(matches)
         else gr.update(value="", visible=False)
         for i in range(N_SUGGESTIONS)
@@ -586,284 +864,399 @@ def get_suggestions(text):
     return updates + [matches]
 
 
-def _make_fill_fn(idx):
-    def fill(matches):
-        if matches and idx < len(matches):
-            return matches[idx]
-        return gr.update()
-    return fill
-
-# ── CSS ───────────────────────────────────────────────────────────────────────
-custom_css = """
-:root, .dark {
-  --pp-bg:       #0e0f11;
-  --pp-panel:    #17181b;
-  --pp-card:     #1d1f23;
-  --pp-border:   #2a2c31;
-  --pp-accent-a: #7f77dd;
-  --pp-accent-b: #1d9e75;
-  --pp-text:     #eaeaec;
-  --pp-text-dim: #9a9ba0;
-}
-.gradio-container {
-  background: var(--pp-bg) !important;
-  color: var(--pp-text) !important;
-  max-width: 1200px !important;
-}
-.pp-hero {
-  background: linear-gradient(135deg, rgba(127,119,221,0.18), rgba(29,158,117,0.12));
-  border: 1px solid var(--pp-border);
-  border-radius: 16px;
-  padding: 18px 22px;
-  margin-bottom: 14px;
-}
-.pp-hero h1 { font-size: 20px; margin: 0 0 4px; font-weight: 600; }
-.pp-hero p  { margin: 0; color: var(--pp-text-dim); font-size: 13px; }
-.pp-badges  { margin-top: 10px; display: flex; gap: 8px; flex-wrap: wrap; }
-.pp-stat-badge {
-  background: rgba(127,119,221,0.15);
-  border: 1px solid rgba(127,119,221,0.3);
-  color: #b9b3f2;
-  border-radius: 999px;
-  padding: 3px 10px;
-  font-size: 12px;
+# ── Gradio process function (streaming) ────────────────────────────────────────
+# Minimum gap between UI updates while a response is streaming in. Individual
+# streamer chunks can arrive many times a second; without this, a 340-token
+# response would push ~340 websocket updates. 120ms keeps the "typing" feel
+# smooth without spamming the connection.
+_STREAM_THROTTLE_S = 0.12
+
+
+def process(tenant_message, building_id, unit):
+    if not tenant_message.strip():
+        yield "", "", "", "", "Please enter a tenant message.", None, ""
+        return
+
+    # Exact match against a cached Quick Starter (e.g. pasted rather than
+    # clicked) -> instant, deterministic cached result instead of a live LLM
+    # call, same as clicking the button.
+    cached = TEXT_TO_CACHED.get(tenant_message.strip())
+    if cached:
+        bid = building_id.strip() or cached["building_id"]
+        u   = unit.strip() or cached["unit"]
+        yield _render_from_cache(
+            tenant_message.strip(), bid, u, cached,
+            "Matched a known ticket — instant cached result!",
+        )
+        return
+
+    last_yield_at = 0.0
+    for result in run_pipeline_stream(tenant_message, building_id, unit):
+        if result["retrieval"]["status"] == "no_match":
+            yield (
+                "## ⚠️ No Match\n\nInput doesn't resemble a maintenance request.",
+                "_No similar tickets found — similarity below threshold._",
+                "", "",
+                "⚠️ Input not recognized as a maintenance request. Please describe a specific issue.",
+                None, "",
+            )
+            return
+
+        now = time.monotonic()
+        is_final = not result["generating"]
+        if not is_final and (now - last_yield_at) < _STREAM_THROTTLE_S:
+            continue  # skip this chunk, the next one (or the final yield) will catch up
+        last_yield_at = now
+
+        status = (
+            '✍️ Generating<span class="pp-typing-dots"><span></span><span></span><span></span></span> '
+            "(can take up to 1-2 minutes on free CPU hardware — this isn't stuck)"
+            if result["generating"] else "Done!"
+        )
+        result_json = json.dumps(result, default=str) if is_final else None
+        yield (fmt_triage(result), fmt_similar(result),
+               result["work_order"], result["tenant_reply"],
+               status, result_json, fmt_yelp_link(result))
+
+
+# ── Theme + custom styling ──────────────────────────────────────────────────────
+THEME = gr.themes.Soft(
+    primary_hue=gr.themes.colors.indigo,
+    secondary_hue=gr.themes.colors.amber,
+    neutral_hue=gr.themes.colors.slate,
+    font=[gr.themes.GoogleFont("Inter"), "ui-sans-serif", "system-ui", "sans-serif"],
+).set(
+    body_background_fill="*neutral_50",
+    body_background_fill_dark="*neutral_950",
+    block_background_fill="white",
+    block_background_fill_dark="*neutral_800",
+    block_border_width="1px",
+    block_border_color="*neutral_200",
+    block_border_color_dark="*neutral_700",
+    block_radius="16px",
+    block_shadow="0 4px 14px rgba(15, 23, 42, 0.10)",
+    block_label_text_weight="600",
+    body_text_color="*neutral_800",
+    body_text_color_dark="*neutral_100",
+    button_large_radius="12px",
+    button_small_radius="10px",
+    button_primary_background_fill="*primary_600",
+    button_primary_background_fill_hover="*primary_700",
+)
+
+CSS = """
+.pp-header {
+    background: linear-gradient(135deg, #4338ca 0%, #6d28d9 60%, #7c3aed 100%);
+    border-radius: 20px;
+    padding: 32px 36px;
+    margin-bottom: 20px;
+    box-shadow: 0 10px 25px rgba(67, 56, 202, 0.25);
 }
-.pp-panel {
-  background: var(--pp-panel) !important;
-  border: 1px solid var(--pp-border) !important;
-  border-radius: 14px !important;
+.pp-header h1 { color: white !important; margin: 0 0 6px 0; font-size: 1.9rem; font-weight: 700; }
+.pp-header p  { color: rgba(255,255,255,0.92) !important; margin: 0; font-size: 1.02rem; }
+.pp-badges { margin-top: 16px; display: flex; gap: 10px; flex-wrap: wrap; }
+.pp-badge {
+    display: inline-block; background: rgba(255,255,255,0.16); color: white;
+    padding: 4px 12px; border-radius: 999px; font-size: 0.8rem; font-weight: 500;
 }
-.pp-quick-row button {
-  background: var(--pp-card) !important;
-  border: 1px solid var(--pp-border) !important;
-  color: var(--pp-text) !important;
-  border-radius: 999px !important;
-  font-size: 12px !important;
+.pp-section-title { font-size: 1.05rem; font-weight: 700; margin: 0 0 10px 0; color: #1e1b4b; }
+/* Target the actual heading element Gradio renders inside the wrapper div,
+   not the div itself -- an ::before on the block-level wrapper puts this
+   inline "▸" glyph before a block child, which forces it onto its own line
+   above the heading instead of sitting next to the text. Gradio also nests
+   an extra "prose" wrapper div between that outer div and the actual <h4>,
+   so even the immediate first child isn't the heading -- target h4 directly
+   via a descendant selector, regardless of how many wrapper divs sit
+   between the elem_classes div and the rendered heading. */
+.pp-section-title-plain h4::before {
+    content: "▸"; color: var(--primary-600); margin-inline-end: 6px;
 }
-.pp-quick-row button:hover { border-color: var(--pp-accent-a) !important; }
-.pp-primary button {
-  background: linear-gradient(135deg, var(--pp-accent-a), var(--pp-accent-b)) !important;
-  border: none !important;
-  color: #fff !important;
-  font-weight: 600 !important;
+.pp-card { border-radius: 16px !important; }
+#qs-grid button, #suggestion-row button { border-radius: 10px !important; }
+#suggestion-row button { font-size: 0.82rem !important; }
+footer { visibility: hidden; }
+
+/* Dark mode — hard fallback rules (not just theme variables), so the page
+   background and card backgrounds definitely flip even if Gradio's own
+   variable system is scoped to a different ancestor than the one we toggle. */
+.dark, .dark .gradio-container, body.dark {
+    background: #0b0b14 !important;
 }
-.pp-timeline { display: flex; flex-direction: column; gap: 10px; }
-.pp-bubble {
-  align-self: flex-end;
-  max-width: 82%;
-  background: var(--pp-card);
-  border: 1px solid var(--pp-border);
-  border-radius: 14px 14px 4px 14px;
-  padding: 10px 14px;
+.dark .pp-header {
+    background: linear-gradient(135deg, #312e81 0%, #4c1d95 60%, #5b21b6 100%) !important;
+    box-shadow: 0 10px 25px rgba(0, 0, 0, 0.4);
 }
-.pp-bubble-meta { font-size: 10px; color: var(--pp-text-dim); text-transform: uppercase; letter-spacing: .04em; }
-.pp-bubble p { margin: 4px 0 0; font-size: 13px; line-height: 1.5; }
-.pp-node { display: flex; gap: 10px; }
-.pp-node-last { margin-top: -2px; }
-.pp-dot { width: 8px; height: 8px; border-radius: 50%; margin-top: 16px; flex-shrink: 0; }
-.pp-dot-purple { background: var(--pp-accent-a); }
-.pp-dot-pink   { background: #d4537e; }
-.pp-card {
-  flex: 1;
-  background: var(--pp-card);
-  border: 1px solid var(--pp-border);
-  border-radius: 12px;
-  padding: 12px 14px;
+.dark .pp-section-title { color: #c7d2fe !important; }
+.dark .pp-badge { background: rgba(255,255,255,0.12) !important; }
+.dark .pp-card, .dark .gr-group, .dark .block {
+    background: #16162a !important;
+    border-color: #2e2e4d !important;
 }
-.pp-card-label {
-  font-size: 11px; color: var(--pp-text-dim);
-  margin: 0 0 8px; text-transform: uppercase; letter-spacing: .04em;
+.dark .pp-card p, .dark .pp-card span, .dark .pp-card li,
+.dark .gr-group p, .dark .gr-group span {
+    color: #e5e7eb !important;
 }
-.pp-label-purple { color: #b9b3f2; }
-.pp-label-pink   { color: #f0a8c2; }
-.pp-badge {
-  display: inline-block; font-size: 12px; font-weight: 600;
-  padding: 4px 10px; border-radius: 999px; margin-right: 6px; margin-bottom: 4px;
+/* gr.DataFrame (NYC-311 tab) and text inputs weren't covered above, so they
+   stayed light-themed even after toggling to dark mode. */
+.dark table, .dark thead, .dark th, .dark td {
+    background: #16162a !important;
+    color: #e5e7eb !important;
+    border-color: #2e2e4d !important;
 }
-.pp-sim-row {
-  display: flex; gap: 10px; font-size: 12px;
-  padding: 4px 0; border-top: 1px solid var(--pp-border);
+.dark input, .dark textarea, .dark select {
+    background: #16162a !important;
+    color: #e5e7eb !important;
+    border-color: #2e2e4d !important;
 }
-.pp-sim-row:first-child { border-top: none; }
-.pp-sim-id    { color: var(--pp-text-dim); min-width: 60px; }
-.pp-sim-text  { flex: 1; }
-.pp-sim-score { color: #7bdc9f; min-width: 40px; text-align: right; }
-.pp-empty     { color: var(--pp-text-dim); }
-.pp-empty-state { color: var(--pp-text-dim); font-size: 13px; padding: 24px 4px; }
-.pp-pre {
-  white-space: pre-wrap; font-family: inherit;
-  font-size: 12.5px; line-height: 1.6; margin: 0; color: var(--pp-text);
+
+/* ── Priority pill (fmt_triage headline) ──────────────────────────────────── */
+.pp-priority-pill {
+    display: inline-block; border-radius: 999px; padding: 6px 16px;
+    font-weight: 700; font-size: 1.1rem;
 }
-.pp-contractor {
-  font-size: 12px; color: #b9b3f2;
-  margin-top: 8px; padding-top: 8px; border-top: 1px solid var(--pp-border);
+
+/* ── Result-card hover lift ───────────────────────────────────────────────── */
+.pp-card { transition: box-shadow .2s ease, transform .2s ease; }
+.pp-card:hover { box-shadow: 0 8px 20px rgba(67,56,202,0.15); transform: translateY(-2px); }
+
+/* ── Equal card heights within a row (Triage/Similar, Work Order/Reply) ────── */
+.pp-result-card-row { display: flex; align-items: stretch; }
+.pp-result-card { display: flex; flex-direction: column; flex: 1; }
+
+/* ── Expand/Collapse toggle (client-side only, see items 1-2) ──────────────── */
+#wo-box textarea, #reply-box textarea { transition: height .2s ease, max-height .2s ease; }
+.pp-expanded textarea { max-height: none !important; height: 400px !important; }
+
+/* ── Quick Starter selected state ─────────────────────────────────────────── */
+/* Solid, fixed-contrast background instead of a light tint (--primary-50) --
+   the light tint put near-invisible light-on-light text in dark mode, since
+   button text stays light-colored there. This reads correctly in both. */
+.qs-selected, .qs-selected:hover {
+    border: 2px solid var(--primary-600) !important;
+    background: var(--primary-600) !important;
 }
-.pp-fiverr-btn {
-  display: inline-block;
-  background: linear-gradient(135deg, #1dbf73, #17a060);
-  color: #fff !important;
-  border-radius: 999px;
-  padding: 5px 16px;
-  font-size: 12px;
-  font-weight: 600;
-  text-decoration: none !important;
-  transition: opacity 0.15s;
+.qs-selected, .qs-selected * { color: #ffffff !important; }
+
+/* ── Similarity match bar (fmt_similar) ───────────────────────────────────── */
+.pp-match-bar { background: #e5e7eb; border-radius: 6px; height: 6px; width: 100%; margin: 4px 0; }
+.dark .pp-match-bar { background: #2e2e4d; }
+.pp-match-bar-fill { height: 100%; border-radius: 6px; }
+
+/* ── Typing-dots loader (generation status) ───────────────────────────────── */
+.pp-typing-dots span {
+    display: inline-block; width: 6px; height: 6px; margin: 0 2px;
+    background: var(--primary-600); border-radius: 50%;
+    animation: pp-bounce 1.4s infinite ease-in-out both;
 }
-.pp-fiverr-btn:hover { opacity: 0.85; }
+.pp-typing-dots span:nth-child(1) { animation-delay: -0.32s; }
+.pp-typing-dots span:nth-child(2) { animation-delay: -0.16s; }
+@keyframes pp-bounce { 0%, 80%, 100% { transform: scale(0); } 40% { transform: scale(1); } }
 """
 
-# ── UI ─────────────────────────────────────────────────────────────────────────
-QUICK_LABELS = sorted(QUICK_STARTERS_CACHE.keys()) if QUICK_STARTERS_CACHE else list(CATEGORY_ICONS.keys())
-
-with gr.Blocks(
-    title="PropertyPilot — AI Maintenance Assistant",
-    css=custom_css,
-) as demo:
-
-    result_state     = gr.State(None)
-    suggestions_state = gr.State([])
-
-    gr.HTML("""
-    <div class="pp-hero">
-      <h1>🏢 PropertyPilot — AI Maintenance Assistant</h1>
-      <p>Paste a tenant maintenance message and get instant triage, similar past tickets,
-         a contractor work order, a tone-matched tenant reply, and a Fiverr contractor search link.</p>
-      <div class="pp-badges">
-        <span class="pp-stat-badge">🗂️ 13,798 tickets analyzed</span>
-        <span class="pp-stat-badge">🧭 10 categories</span>
-        <span class="pp-stat-badge">⚡ FAISS-powered retrieval</span>
-        <span class="pp-stat-badge">🤖 QLoRA finetuned Qwen2.5-1.5B</span>
-        <span class="pp-stat-badge">🗽 Live NYC-311 feed</span>
-        <span class="pp-stat-badge">🔗 Fiverr contractor search</span>
-      </div>
-    </div>
-    """)
+# ── Build UI ───────────────────────────────────────────────────────────────────
+with gr.Blocks(title="PropertyPilot v2", theme=THEME, css=CSS, fill_width=True) as demo:
+    gr.HTML(
+        f"""
+        <div class="pp-header">
+          <h1>🏢 PropertyPilot — AI Maintenance Assistant</h1>
+          <p>Paste a tenant maintenance message and get instant triage, similar past
+             tickets, a contractor work order, and a tone-matched tenant reply.</p>
+          <div class="pp-badges">
+            <span class="pp-badge">🗂️ {len(df):,} tickets analyzed</span>
+            <span class="pp-badge">🧭 10 categories</span>
+            <span class="pp-badge">⚡ FAISS-powered retrieval</span>
+            <span class="pp-badge">🗽 Live NYC-311 feed</span>
+          </div>
+        </div>
+        """
+    )
+    with gr.Row():
+        gr.Markdown("")
+        dark_toggle = gr.Button("☀️ Day Mode", size="sm", variant="secondary", scale=0)
+    dark_toggle.click(
+        fn=None,
+        js="""
+        () => {
+            // Toggle on every likely ancestor Gradio/our CSS might key off of,
+            // so the whole page (background included) flips consistently.
+            document.body.classList.toggle('dark');
+            document.documentElement.classList.toggle('dark');
+            document.querySelectorAll('.gradio-container').forEach(
+                el => el.classList.toggle('dark')
+            );
+            // gr.DataFrame (NYC-311 tab) doesn't reliably inherit the
+            // ancestor .dark class through CSS alone -- toggle it directly.
+            document.querySelectorAll('table').forEach(el => el.classList.toggle('dark'));
+        }
+        """,
+    )
+    # Dark mode by default on page load.
+    demo.load(
+        fn=None,
+        js="""
+        () => {
+            document.body.classList.add('dark');
+            document.documentElement.classList.add('dark');
+            document.querySelectorAll('table').forEach(el => el.classList.add('dark'));
+            document.querySelectorAll('.gradio-container').forEach(
+                el => el.classList.add('dark')
+            );
+        }
+        """,
+    )
 
     with gr.Tabs():
 
-        # ── Process Ticket tab ────────────────────────────────────────────────
         with gr.Tab("🎫 Process Ticket"):
-            with gr.Row():
-
-                # Left panel — inputs
-                with gr.Column(scale=2, elem_classes=["pp-panel"]):
-                    gr.Markdown("**⚡ Quick Starters** *(instant, cached — no waiting)*")
-                    qs_btns = []
-                    with gr.Row(elem_classes=["pp-quick-row"]):
-                        for cat in QUICK_LABELS[:5]:
-                            lbl = f"{CATEGORY_ICONS.get(cat, '🔧')} {cat}"
-                            qs_btns.append((cat, gr.Button(lbl, size="sm")))
-                    with gr.Row(elem_classes=["pp-quick-row"]):
-                        for cat in QUICK_LABELS[5:]:
-                            lbl = f"{CATEGORY_ICONS.get(cat, '🔧')} {cat}"
-                            qs_btns.append((cat, gr.Button(lbl, size="sm")))
-
-                    msg_box = gr.Textbox(
-                        label="📝 Describe the Issue",
-                        placeholder="Paste the tenant's maintenance message here… (start typing for suggestions)",
-                        lines=5,
-                    )
-
-                    # Autocomplete suggestion buttons
-                    suggestion_btns = []
-                    with gr.Row():
-                        for _ in range(N_SUGGESTIONS):
-                            suggestion_btns.append(gr.Button("", visible=False, size="sm"))
-
-                    with gr.Row():
-                        bldg_box = gr.Textbox(label="🏠 Building ID", value="B-01")
-                        unit_box = gr.Textbox(label="🚪 Unit", value="1A")
-
-                    with gr.Row():
-                        analyze_btn = gr.Button("✨ Analyze & Generate", elem_classes=["pp-primary"])
-                        clear_btn   = gr.Button("🗑️ Clear")
-
-                    status_md = gr.Markdown("")
-
-                    night_mode = gr.Checkbox(label="🌙 Night Mode", value=True)
-
-                    gr.Markdown("---\n**📡 Ops Dispatch**")
-                    slack_btn = gr.Button("📤 Send to Slack Ops Channel")
-                    slack_md  = gr.Markdown("")
-
-                # Right panel — timeline output
-                with gr.Column(scale=3, elem_classes=["pp-panel"]):
-                    triage_label  = gr.Markdown("")
-                    timeline_html = gr.HTML(_EMPTY_TIMELINE)
-                    with gr.Accordion("📄 Raw work order / reply text", open=False):
-                        work_order_box = gr.Textbox(label="Work order",   lines=6, interactive=False, show_copy_button=True)
-                        reply_box      = gr.Textbox(label="Tenant reply", lines=4, interactive=False, show_copy_button=True)
-
-            # Wire analyze
-            analyze_btn.click(
-                process,
-                inputs=[msg_box, bldg_box, unit_box],
-                outputs=[timeline_html, work_order_box, reply_box, triage_label, status_md, result_state],
-            )
-
-            # Wire clear
-            clear_btn.click(
-                clear_all,
-                outputs=[msg_box, bldg_box, unit_box, timeline_html,
-                         work_order_box, reply_box, triage_label, status_md, result_state],
-            )
-
-            # Wire Slack
-            slack_btn.click(send_to_slack, inputs=[result_state], outputs=[slack_md])
+            with gr.Group(elem_classes=["pp-card"]):
+                gr.Markdown("#### Quick Starters _(instant, cached — no waiting)_",
+                            elem_classes=["pp-section-title", "pp-section-title-plain"])
+                qs_categories = sorted(QUICK_STARTERS_CACHE.keys())
+                qs_btns = []
+                with gr.Column(elem_id="qs-grid"):
+                    for row_start in range(0, len(qs_categories), 5):
+                        with gr.Row():
+                            for cat in qs_categories[row_start:row_start + 5]:
+                                label = f"{CATEGORY_ICON.get(cat, '🔧')} {cat}"
+                                qs_btns.append((cat, gr.Button(
+                                    label, variant="secondary", size="sm",
+                                    elem_id=f"qs-{cat.replace(' ', '-')}")))
+
+            with gr.Group(elem_classes=["pp-card"]):
+                gr.Markdown("#### Describe the Issue", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                msg_box = gr.Textbox(
+                    label="Tenant Message", lines=4, show_label=False,
+                    placeholder="Paste the tenant's maintenance message here... "
+                                "(start typing to see suggestions)",
+                )
+                with gr.Row(elem_id="suggestion-row"):
+                    suggestion_btns = [
+                        gr.Button("", visible=False, size="sm", variant="secondary")
+                        for _ in range(N_SUGGESTIONS)
+                    ]
+                suggestions_state = gr.State([])
+                with gr.Row():
+                    bldg_box = gr.Textbox(label="🏠 Building ID", value="B-01", scale=1)
+                    unit_box = gr.Textbox(label="🚪 Unit", value="1A", scale=1)
+                with gr.Row():
+                    run_btn   = gr.Button("✨ Analyze & Generate", variant="primary", size="lg", scale=3)
+                    clear_btn = gr.Button("🗑️ Clear", variant="secondary", size="lg", scale=1)
+
+            status_md = gr.Markdown("")
+
+            _EMPTY_HINT = "_Results will appear here after you analyze a ticket._"
+
+            with gr.Row(elem_classes=["pp-result-card-row"]):
+                with gr.Group(elem_classes=["pp-card", "pp-result-card"]):
+                    gr.Markdown("#### Triage", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                    triage_md = gr.Markdown(_EMPTY_HINT)
+                with gr.Group(elem_classes=["pp-card", "pp-result-card"]):
+                    gr.Markdown("#### Similar Past Tickets", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                    similar_md = gr.Markdown(_EMPTY_HINT)
+
+            with gr.Row(elem_classes=["pp-result-card-row"]):
+                with gr.Group(elem_classes=["pp-card", "pp-result-card"]):
+                    gr.Markdown("#### Work Order _(for contractor)_", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                    workorder_box = gr.Textbox(lines=7, interactive=False, show_label=False,
+                                               show_copy_button=True, elem_id="wo-box")
+                    expand_wo_btn = gr.Button("⤢ Expand", size="sm", variant="secondary",
+                                              elem_id="wo-expand-btn")
+                    # Pure client-side toggle -- a server round-trip (the old
+                    # gr.update(lines=...) approach) re-renders the component
+                    # and resets page scroll, which is jarring right after the
+                    # user scrolled down to reach this button.
+                    expand_wo_btn.click(fn=None, js="""
+                    () => {
+                        const box = document.getElementById('wo-box');
+                        const btn = document.getElementById('wo-expand-btn');
+                        const expanded = box.classList.toggle('pp-expanded');
+                        btn.textContent = expanded ? '⤡ Collapse' : '⤢ Expand';
+                    }
+                    """)
+                with gr.Group(elem_classes=["pp-card", "pp-result-card"]):
+                    gr.Markdown("#### Tenant Reply _(tone-matched)_", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                    reply_box = gr.Textbox(lines=7, interactive=False, show_label=False,
+                                           show_copy_button=True, elem_id="reply-box")
+                    expand_reply_btn = gr.Button("⤢ Expand", size="sm", variant="secondary",
+                                                 elem_id="reply-expand-btn")
+                    expand_reply_btn.click(fn=None, js="""
+                    () => {
+                        const box = document.getElementById('reply-box');
+                        const btn = document.getElementById('reply-expand-btn');
+                        const expanded = box.classList.toggle('pp-expanded');
+                        btn.textContent = expanded ? '⤡ Collapse' : '⤢ Expand';
+                    }
+                    """)
+
+            result_state = gr.State(None)
+
+            with gr.Group(elem_classes=["pp-card"]):
+                gr.Markdown("#### Find a Real Contractor (New York City)", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                yelp_md = gr.Markdown("_Analyze a ticket to get a Yelp contractor search link._")
+
+            with gr.Group(elem_classes=["pp-card"]):
+                gr.Markdown("#### Ops Dispatch", elem_classes=["pp-section-title", "pp-section-title-plain"])
+                with gr.Row():
+                    slack_btn  = gr.Button("Send to Slack Ops Channel", variant="secondary")
+                slack_md = gr.Markdown("")
 
-            # Wire Quick Starters
             for cat, btn in qs_btns:
                 btn.click(
-                    lambda c=cat: use_cached_quick_starter(c),
-                    outputs=[msg_box, bldg_box, unit_box, timeline_html,
-                             work_order_box, reply_box, triage_label, status_md, result_state],
+                    fn=lambda _cat=cat: use_cached_quick_starter(_cat),
+                    outputs=[msg_box, bldg_box, unit_box, triage_md, similar_md,
+                             workorder_box, reply_box, status_md, result_state, yelp_md],
                 )
-
-            # Wire autocomplete
-            msg_box.change(
-                get_suggestions,
+                # Cosmetic only -- visually mark which Quick Starter was last
+                # clicked, doesn't touch the cached-result logic above.
+                btn.click(fn=None, js=f"""
+                () => {{
+                    document.querySelectorAll('#qs-grid button').forEach(b => b.classList.remove('qs-selected'));
+                    document.getElementById('qs-{cat.replace(" ", "-")}').classList.add('qs-selected');
+                }}
+                """)
+
+            msg_box.input(
+                fn=get_suggestions,
                 inputs=[msg_box],
                 outputs=suggestion_btns + [suggestions_state],
             )
-            for i, sb in enumerate(suggestion_btns):
-                sb.click(_make_fill_fn(i), inputs=[suggestions_state], outputs=[msg_box])
+            for i, sbtn in enumerate(suggestion_btns):
+                sbtn.click(
+                    fn=lambda matches, _i=i: matches[_i] if _i < len(matches) else gr.update(),
+                    inputs=[suggestions_state],
+                    outputs=[msg_box],
+                )
 
-            # Night mode toggle
-            night_mode.change(
-                None, [night_mode], None,
-                js="(v) => { document.querySelector('.gradio-container').classList.toggle('dark', v); }",
+            run_btn.click(
+                fn=process,
+                inputs=[msg_box, bldg_box, unit_box],
+                outputs=[triage_md, similar_md, workorder_box, reply_box,
+                         status_md, result_state, yelp_md],
             )
 
-        # ── NYC-311 Live Feed tab ─────────────────────────────────────────────
-        with gr.Tab("🗽 NYC-311 Live Feed"):
-            gr.Markdown(
-                "#### Real-Time Maintenance Complaints — New York City\n"
-                "Live data from NYC Open Data (no API key required). "
-                "Filtered to building maintenance categories. "
-                "Pick a row and run it through the full pipeline."
-            )
-            nyc_refresh = gr.Button("🔄 Refresh Feed", variant="primary")
-            nyc_status  = gr.Markdown("")
-            nyc_table   = gr.DataFrame(interactive=False)
-
-            gr.Markdown("---")
-            row_index       = gr.Number(label="Row # to analyze (0-based)", value=0, precision=0)
-            process_311_btn = gr.Button("✨ Analyze this complaint", variant="primary")
-
-            triage_label_311 = gr.Markdown("")
-            timeline_311     = gr.HTML(_EMPTY_TIMELINE)
-            with gr.Accordion("📄 Raw work order / reply text", open=False):
-                work_order_311 = gr.Textbox(label="Work order",   lines=6, interactive=False, show_copy_button=True)
-                reply_311      = gr.Textbox(label="Tenant reply", lines=4, interactive=False, show_copy_button=True)
-            status_311 = gr.Markdown("")
-            state_311  = gr.State(None)
-
-            nyc_refresh.click(fn=fetch_nyc311, outputs=[nyc_table, nyc_status])
-            process_311_btn.click(
-                process_311_row,
-                inputs=[row_index],
-                outputs=[timeline_311, work_order_311, reply_311,
-                         triage_label_311, status_311, state_311],
+            slack_btn.click(fn=send_to_slack, inputs=[result_state], outputs=[slack_md])
+
+            clear_btn.click(
+                fn=lambda: ("", "B-01", "1A", _EMPTY_HINT, _EMPTY_HINT, "", "", "", None, ""),
+                outputs=[msg_box, bldg_box, unit_box, triage_md, similar_md,
+                         workorder_box, reply_box, status_md, result_state, yelp_md],
             )
 
+        with gr.Tab("🗽 NYC-311 Live Feed"):
+            with gr.Group(elem_classes=["pp-card"]):
+                gr.Markdown(
+                    "#### Real-Time Maintenance Complaints — New York City\n"
+                    "Live data from NYC Open Data (no API key required). "
+                    "Filtered to building maintenance categories.",
+                    elem_classes=["pp-section-title", "pp-section-title-plain"],
+                )
+                nyc_refresh = gr.Button("🔄 Refresh Feed", variant="primary")
+                nyc_status  = gr.Markdown("")
+                nyc_table   = gr.DataFrame(
+                    interactive=False,
+                    datatype=["str", "str", "str", "str", "markdown", "str"],
+                )
+                nyc_refresh.click(fn=fetch_nyc311, outputs=[nyc_table, nyc_status])
+                demo.load(fn=fetch_nyc311, outputs=[nyc_table, nyc_status])
+
 demo.launch()