fix: KI-036/037/038 — greeting flow, strict paraphrase verifier, waiting dots

Three user-reported UX bugs from voice-mode testing, all fixed together.

KI-036 (orchestrator + paraphraser) — Strict paraphrase end-of-string
check. Previous verifier checked `"?" in paraphrase` (anywhere), letting
the dependents-slot paraphrase emit "...have their own insurance
options.?" — period AND question mark at end. Now require
`paraphrase.rstrip().endswith("?")` AND reject malformed sequences:
".?", "?.", "??", "!?", "?!", ",?". On rejection, fall back to canonical
question text (no UX regression).

KI-037 (orchestrator) — Greeting + intent-restart detection. Previous
behavior: ANY message arriving while `session.awaiting_question_id` was
set got parsed as an attempted answer. User opening the bot with "Hi, I
am looking to buy an insurance policy." after a prior partial fact-find
got "Sorry, I didn't catch that. Let me ask again — Who else needs
cover..." — which feels broken because the user intended a fresh start.

Fix:
• Pure-greeting detector — input that, after stripping punctuation, is
only words from {"hi", "hello", "hey", "namaste", "yo", "hola"}.
• Intent-restart detector — phrases like "i am looking", "want to buy",
"i need health insurance", "help me find", "first time".
• If either fires AND awaiting_question_id is set: clear the slot,
clear _reask_counts, recompute in_fact_find_continuation. Lets the
fact-find flow re-enter cleanly.
• Pure greeting on empty profile gets a WARM WELCOME message
(brain_tag "greeting::welcome") with an offer to start a 2-min
profile OR answer a specific question — NOT immediate age grilling.

KI-038 (frontend) — Visible waiting indicator. ThinkingDots now takes a
`phase` prop and renders different labels:
• "Hearing you…" — STT is transcribing the user's voice (~1-2s gap
that was previously invisible — user finished speaking, nothing on
screen until the user-bubble landed)
• "Thinking…" — brain in flight (existing behavior; was unlabeled)
• "Speaking…" — TTS playing (informational)

State machine: setVoicePhase("transcribing") before postTranscribe,
flip to "thinking" after pushUser, clear in finally{}. Wired across
Live mode, push-to-talk, and the typed-send flow.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -126,107 +126,191 @@ A **voice-first conversational advisor** that:
 
 ## 3. Two parallel flows
 
-The bot is two flows running together — the customer's experience and the technology underneath. They are intentionally separated below so a reviewer can scan either.
+The bot is two flows running together — the customer's experience and the technology underneath. They run in lockstep; the table below pairs each step of the user journey with the technology underneath. On narrow screens both columns are scrollable; on a desktop GitHub view they sit side-by-side.
 
-### 3A. Customer / Process Flow
+<table>
+<tr>
+<th width="50%">3A · Customer / Process Flow</th>
+<th width="50%">3B · Technology Flow (same turn, underneath)</th>
+</tr>
+<tr><td>
 
-What a buyer experiences, end to end.
+**Step 1 — Land on the bot**
+- Sees: chat panel + Marketplace · Premium · Profile · Admin tabs
+- Suggested questions in the chat box
+- "Voice on — just speak" pill (Live mode, default ON) with green dot
+- "🎤 Push-to-talk" button as labeled fallback
+- "Voice reply" toggle controls whether the bot speaks back
 
-```
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 1.  Land on the bot                                                │
-│  -------                                                                  │
-│  · Sees: chat panel + Marketplace · Premium · Profile · Admin tabs       │
-│  · Suggested questions in the chat box                                   │
-│  · "Voice on — just speak" pill (Live mode, default ON) with green dot   │
-│  · "🎤 Push-to-talk" button as labeled fallback                          │
-│  · "Voice reply" toggle controls whether the bot speaks back             │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 2.  Ask the first question (voice or text)                          │
-│  -------                                                                  │
-│  · User just talks — VAD detects speech start/end automatically          │
-│  · "Suggest a health insurance plan for me"                              │
-│  · Bot recognizes fact-find intent. The orchestrator picks the next      │
-│    slot from a 9-question graph; an LLM paraphraser rewrites the         │
-│    canonical question in a warmer voice each session (verified to        │
-│    still target the same slot before sending).                           │
-│  · Slots covered in order: age → dependents → income → existing cover    │
-│    → primary goal → location → parents (conditional) → health → budget   │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 3.  Profile-driven personalization unlocks                         │
-│  -------                                                                  │
-│  · Completeness bar reaches ≥60% → "personalized scores unlocked"        │
-│  · Marketplace tab now shows per-policy A-F grades RE-COMPUTED for       │
-│    this user's specific situation                                        │
-│  · Chat references your profile inline ("at 32 with 1 dependent…")       │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 4.  Free-form questions with citations                              │
-│  -------                                                                  │
-│  · "What's the room rent cap on Care Supreme?"                            │
-│  · "Compare cataract waiting in HDFC Optima vs ICICI Elevate"             │
-│  · Every factual claim gets [Source: <policy>, p.<page>] citation        │
-│  · Click a citation → opens the policy detail modal                       │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 5.  Conversational profile updates (mid-chat)                       │
-│  -------                                                                  │
-│  · User says: "I was just diagnosed with diabetes"                        │
-│  · Bot silently extracts → updates session.profile → re-upserts profile  │
-│    chunk → completeness bar ticks up → scores refresh                    │
-│  · No form-filling required mid-conversation                              │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 6.  View-aware grounding (the copilot effect)                       │
-│  -------                                                                  │
-│  · User opens a policy detail modal                                       │
-│  · Asks "What's the waiting period on this?"                              │
-│  · Bot resolves "this" → answers without re-stating policy name          │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 7.  Refusal as a feature                                            │
-│  -------                                                                  │
-│  · User: "Does this policy cover space-tourism injuries?"                 │
-│  · Bot: "I'd rather not answer that without stronger evidence in the     │
-│    policy documents I have."                                              │
-│  · The SAFE failure mode in BFSI is refuse > mis-cite                    │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 8.  Hindi / Hinglish flow                                           │
-│  -------                                                                  │
-│  · User switches UI language toggle, or just speaks Hinglish              │
-│  · "Care Supreme mein PED ka waiting period kya hai?"                     │
-│  · Bot responds in Hinglish with citations preserved                      │
-└──────────────────────────────────────────────────────────────────────────┘
-                                  │
-                                  ▼
-┌──────────────────────────────────────────────────────────────────────────┐
-│  STEP 9.  Persistent chat across sessions                                 │
-│  -------                                                                  │
-│  · Close tab, come back tomorrow: chat history + profile restored        │
-│  · Sessions persisted to disk on backend; local storage on frontend      │
-└──────────────────────────────────────────────────────────────────────────┘
-```
+</td><td>
+
+**Tech 1 — Page load**
+- Next.js 14 SSR ships HTML in ~200 ms
+- React hydrates; useEffect fetches `/api/health`, `/api/coverage`, `/api/profile/completeness`
+- `localStorage` rehydrates `messages[]` + `sessionId` if returning user
+- `useLiveConversation` opens the persistent mic stream
+
+</td></tr>
+
+<tr><td>
+
+**Step 2 — Ask the first question (voice or text)**
+- User just talks — VAD detects speech start/end automatically
+- *"Suggest a health insurance plan for me"*
+- Bot recognises fact-find intent. The orchestrator picks the next slot from a 9-question graph; an LLM paraphraser rewrites the canonical question in a warmer voice each session (verified to still target the same slot before sending)
+- Slots in order: age → dependents → income → existing cover → primary goal → location → parents (conditional) → health → budget
+
+</td><td>
+
+**Tech 2 — User submits**
+- Voice path: `MediaRecorder` blob → `POST /api/transcribe` → Sarvam Saarika v2.5 STT → text
+- Text path: direct `POST /api/chat`
+- Payload: `user_text`, `session_id`, `chat_history[]`, `return_audio`, `tts_language_code`, `view_context { active_view, active_policy_id, filters }`
+
+**Tech 3 — Orchestrator entry, `handle_turn()`**
+- `classify_intent(user_text)` → `fact_find / qa / comparison / recommendation`
+- `detect_language(user_text)` → `english / indic`
+- Indic cascade: if indic, Sarvam-M translates → English for reasoning, response translated back
+
+**Tech 4 — Fact-find branch**
+- If profile empty AND intent ∈ {fact_find, recommendation, comparison}: pick next slot, paraphrase via `question_paraphraser` + verifier, emit question, return early
+- Else: continue to retrieval
+
+</td></tr>
+
+<tr><td>
+
+**Step 3 — Profile-driven personalisation unlocks**
+- Completeness bar reaches ≥ 60% → "personalised scores unlocked"
+- Marketplace tab shows per-policy A-F grades **re-computed for this user's specific situation**
+- Chat references your profile inline ("at 32 with 1 dependent…")
+
+</td><td>
+
+**Tech 5 — Profile update extraction (free-form turns)**
+- `extract_profile_updates(user_text, session.profile)` via the fast-brain chain (Nemotron 30B primary)
+- Validation: enum / type / bounds checks; drop on failure
+- Apply via `session.update_profile_field()`
+- `upsert_profile_chunk()` re-embeds profile → Chroma so this turn's retrieval sees the fresh state
+
+</td></tr>
+
+<tr><td>
+
+**Step 4 — Free-form questions with citations**
+- *"What's the room rent cap on Care Supreme?"*
+- *"Compare cataract waiting in HDFC Optima vs ICICI Elevate"*
+- Every factual claim gets `[Source: <policy>, p.<page>]` citation
+- Click a citation → opens the policy detail modal
+
+</td><td>
+
+**Tech 6 — Retrieval, `retrieve(query, session_id)`**
+- LRU cache (key = normalised query + filters) — cache hit skips Voyage + Chroma
+- BGE-small embeds user text → 384-d vector
+- Chroma cosine search, `top_k=5`
+- Profile chunk (`doc_type='profile'`) boosted to top
+- Second pass on regulatory chunks if query mentions IRDAI / Section
+- Returns `list[RetrievedChunk(policy_id, page_start, page_end, text, source_url, score)]`
+
+</td></tr>
+
+<tr><td>
+
+**Step 5 — Conversational profile updates (mid-chat)**
+- User says: *"I was just diagnosed with diabetes"*
+- Bot silently extracts → updates `session.profile` → re-upserts profile chunk → completeness bar ticks up → scores refresh
+- No form-filling required mid-conversation
+
+</td><td>
+
+**Tech 7 — Brain selection, `pick_brain(intent, language)`**
+- `intent ∈ {comparison, recommendation}` → BRAIN_CHAIN (Qwen 80B primary, 50/50 with Groq Llama-3.3)
+- `intent ∈ {qa, fact_find}` → FAST_BRAIN_CHAIN (Nemotron Nano 30B primary)
+- Per-call rotation across two providers' independent rate caps
+
+**Tech 8 — System prompt construction, `build_messages()`**
+- `[System: ADVISOR_PROMPT + USER PROFILE block + USER IS LOOKING AT (view_context) block]`
+- `[Assistant/User: last 5 turns of chat_history]`
+- `[User: USER QUESTION + RETRIEVED POLICY CLAUSES + reply instructions]`
+
+**Tech 9 — Brain LLM call → reply text**
+- `NimChainLLM.chat(...)` with cumulative chain budget (brain 35 s, fast-brain 22 s)
+- `strip_think_tags()` removes `<think>…</think>` reasoning
+- Capture `brain_model_actual` for non-circular judge selection
+
+</td></tr>
+
+<tr><td>
+
+**Step 6 — View-aware grounding (the copilot effect)**
+- User opens a policy detail modal
+- Asks *"What's the waiting period on this?"*
+- Bot resolves *"this"* → answers without re-stating the policy name
+
+</td><td>
+
+**Tech 10 — Faithfulness gates (`backend/faithfulness.py`)**
+- Gate 1 — retrieval floor: top score ≥ 0.30
+- Gate 2 — citation integrity: every cited policy was retrieved
+- Gate 3 — numeric grounding: every ₹/%/days/months/years in the reply appears in retrieved chunks
+- Gate 4 — JUDGE_CHAIN (Mistral Large 3 675B primary, different family from brain)
+- All 4 pass → reply ships
+- Any fail (non-Gate-1) → cross-check retry with the judge model as rescue brain → tagged `crosscheck-rescued-by-judge`
+- Still fails → safe refusal + log to `logs/hallucinations.jsonl`
+
+</td></tr>
+
+<tr><td>
+
+**Step 7 — Refusal as a feature**
+- User: *"Does this policy cover space-tourism injuries?"*
+- Bot: *"I'd rather not answer that without stronger evidence in the policy documents I have."*
+- The SAFE failure mode in BFSI is refuse > mis-cite
+
+</td><td>
+
+**Tech 11 — Indic cascade (only if user spoke Hinglish)**
+- Sarvam-M translates English reply → Hinglish
+- Gate A — regex: digits / citations / currency preserved
+- Gate B — Mistral Large 3 675B LLM-judge for semantic preservation
+- Gate C — back-translation cosine ≥ 0.80
+- Any gate fails → fall back to the English reply
+
+</td></tr>
+
+<tr><td>
+
+**Step 8 — Hindi / Hinglish flow**
+- User switches the UI language toggle, or just speaks Hinglish
+- *"Care Supreme mein PED ka waiting period kya hai?"*
+- Bot responds in Hinglish with citations preserved
+
+</td><td>
+
+**Tech 12 — TTS synthesis (if `return_audio=true`)**
+- `tts_preprocess()` expands acronyms (PED → pre-existing disease) + strips markdown
+- Sarvam Bulbul v2 synthesises → base64 WAV
+- Bundled into the `ChatResponse` alongside `reply_text`
+
+</td></tr>
+
+<tr><td>
+
+**Step 9 — Persistent chat across sessions**
+- Close the tab, come back tomorrow: chat history + profile restored
+- Sessions persisted to disk on the backend; `localStorage` on the frontend
+
+</td><td>
 
-### 3B. Technology Flow (parallel)
+**Tech 13 — Response delivered**
+- `ChatResponse { reply_text, citations[], audio_base64, brain_used, profile_updates, faithfulness_passed, blocked }`
+- Frontend renders text → plays the in-DOM `<audio controls>` (autoplay-on-mount; barge-in pauses it) → updates `profileCompleteness`
+- `localStorage` persists chat history; `session_state._flush()` writes the on-disk session JSON
+- `log_turn()` writes to `logs/turns.jsonl`
 
-What's happening under the hood for the same journey.
+</td></tr>
+</table>
 
 ```
 ┌──────────────────────────────────────────────────────────────────────────┐

backend/orchestrator.py

@@ -231,6 +231,68 @@ async def handle_turn(
         and session.profile.dependents is None
         and session.profile.income_band is None
     )
+
+    # KI-037 (2026-05-14) — greeting + intent-restart detection. The previous
+    # behavior was: any user message arriving while session.awaiting_question_id
+    # was set got parsed as an attempted answer. A user opening the bot with
+    # "Hi, I am looking to buy an insurance policy." would get this parsed as
+    # a (failed) answer to the dependents slot (because earlier turns had
+    # advanced the slot pointer) → "Sorry, I didn't catch that. Let me ask
+    # again — Who else needs cover..." which feels broken because the user
+    # intended a fresh start.
+    #
+    # Fix: if the user's message is a pure greeting or contains explicit
+    # restart intent, CLEAR any stale awaiting slot + reset re-ask counts
+    # so the fact-find re-enters cleanly.
+    _RESTART_INTENT_PHRASES = (
+        "i am looking", "i'm looking", "i want to buy", "want to buy",
+        "looking to buy", "i am here to", "i'm here to",
+        "i need health insurance", "i need insurance",
+        "help me find", "first time", "buy health insurance",
+    )
+    _PURE_GREETING_WORDS = {
+        "hi", "hello", "hey", "namaste", "yo", "hola",
+    }
+    _user_text_lc = user_text.lower().strip()
+    _stripped_user = "".join(c for c in _user_text_lc if c.isalnum() or c.isspace()).strip()
+    _is_pure_greeting = bool(_stripped_user) and all(
+        w in _PURE_GREETING_WORDS for w in _stripped_user.split()
+    )
+    _is_intent_restart = any(p in _user_text_lc for p in _RESTART_INTENT_PHRASES)
+    if (_is_pure_greeting or _is_intent_restart) and session.awaiting_question_id:
+        session.set_awaiting(None)
+        if hasattr(session, "_reask_counts"):
+            session._reask_counts.clear()
+        # Recompute the continuation flag now that we've cleared the slot.
+        in_fact_find_continuation = False
+
+    # KI-037 — pure greeting on empty profile gets a warm welcome, NOT an
+    # immediate age grilling. The bot can answer "Hi" with "Hi!" + offer
+    # before asking for a profile. User feedback: bot grilling for age on
+    # the very first "Hello" feels mechanical and unwelcoming.
+    if _is_pure_greeting and profile_is_empty and not session.free_form_session:
+        reply = (
+            "Hi! I'm an AI advisor for health insurance in India — I've read 208 policy "
+            "documents from 19 insurers plus the IRDAI master circulars, and I can "
+            "answer questions about coverage, waiting periods, exclusions, or "
+            "compare policies side-by-side.\n\n"
+            "Want me to build a 2-minute profile so I can grade each policy *for you* "
+            "specifically, or do you have a question in mind?"
+        )
+        return TurnResult(
+            reply_text=reply,
+            citations=[],
+            retrieved_chunk_ids=[],
+            brain_used="greeting::welcome",
+            intent="fact_find",
+            language=language,
+            latency_ms=int((time.time() - t0) * 1000),
+            raw_reply=reply,
+            faithfulness_passed=True,
+            blocked=False,
+            profile_updates={},
+        )
+
     treat_as_fact_find = should_route_to_fact_find(
         intent,
         profile_is_empty=profile_is_empty,

backend/question_paraphraser.py

@@ -170,8 +170,17 @@ async def paraphrase_question(
                      slot_id, claimed_slot)
         _PARAPHRASE_CACHE[cache_key] = None
         return None
-    if "?" not in paraphrase:
-        logging.info("paraphraser missing '?' slot=%s — falling back", slot_id)
+    # KI-036 (2026-05-14) — strict end-position "?" check + reject malformed
+    # punctuation patterns. Previous lenient `"?" in paraphrase` let outputs
+    # like "...have their own insurance options.?" through, producing
+    # awkward double-punctuation in production.
+    para_stripped = paraphrase.rstrip()
+    if not para_stripped.endswith("?"):
+        logging.info("paraphraser doesn't end with '?' slot=%s — falling back", slot_id)
+        _PARAPHRASE_CACHE[cache_key] = None
+        return None
+    if any(bad in para_stripped for bad in (".?", "?.", "??", "!?", "?!", ",?")):
+        logging.info("paraphraser malformed punctuation slot=%s — falling back", slot_id)
         _PARAPHRASE_CACHE[cache_key] = None
         return None
     if not (30 <= len(paraphrase) <= 500):

frontend/src/app/page.tsx

@@ -52,6 +52,12 @@ export default function Page() {
   const [messages, setMessages] = useState<DisplayMessage[]>([]);
   const [input, setInput] = useState("");
   const [busy, setBusy] = useState(false);
+  // KI-038 (2026-05-14) — voicePhase exposes the otherwise-invisible
+  // "between recording and showing the user bubble" Sarvam-STT gap (~1-2s)
+  // and the "between user bubble and bot reply" /api/chat gap (~5-15s).
+  // null = idle / typed flow, "transcribing" = STT in flight, "thinking" =
+  // brain in flight, "speaking" = TTS playing (informational).
+  const [voicePhase, setVoicePhase] = useState<null | "transcribing" | "thinking" | "speaking">(null);
   const [recording, setRecording] = useState(false);
   const [returnAudio, setReturnAudio] = useState(true);
   const [ttsLang, setTtsLang] = useState<"en-IN" | "hi-IN">("en-IN");
@@ -258,6 +264,7 @@ export default function Page() {
   async function send(text: string) {
     if (!text.trim() || busy) return;
     setBusy(true);
+    setVoicePhase("thinking"); // KI-038 — show "..." while waiting on brain
     setInput("");
 
     // Bug C — if the user is asking us to retry, resubmit the previous user
@@ -352,6 +359,7 @@ export default function Page() {
     } finally {
       setUploadStatus(null);
       setBusy(false);
+      setVoicePhase(null);
     }
   }
 
@@ -360,11 +368,13 @@ export default function Page() {
   useEffect(() => {
     liveOnUtteranceRef.current = async (blob, abort) => {
       try {
+        setVoicePhase("transcribing"); // KI-038 — show indicator while STT runs
         const transcribed = await postTranscribe(blob, ttsLang, abort.signal);
         const text = (transcribed.text || "").trim();
-        if (text.length < 2) return;
+        if (text.length < 2) { setVoicePhase(null); return; }
 
         pushUser(text);
+        setVoicePhase("thinking"); // KI-038 — STT done; brain in flight now
         const history: ChatMessage[] = messages.map((m) => ({ role: m.role, content: m.content }));
         const active_view: "chat" | "marketplace" | "profile" | "premium" | "policy_detail" =
           openPolicy ? "policy_detail" :
@@ -399,9 +409,11 @@ export default function Page() {
         // can pause it. See comment in the typed-send branch.
       } catch (e: unknown) {
         const name = (e as { name?: string })?.name;
-        if (name === "AbortError") return; // user barged in; intentional
+        if (name === "AbortError") { setVoicePhase(null); return; } // barge-in
         // eslint-disable-next-line no-console
         console.error("[live mode] turn failed:", e);
+      } finally {
+        setVoicePhase(null); // KI-038 — clear indicator once turn lands
       }
     };
   }, [messages, sessionId, ttsLang, openPolicy, showMarketplace, showProfile, showPremium]);
@@ -437,14 +449,20 @@ export default function Page() {
         const maybeResumeLive = () => { if (userPrefersLive) live.setLive(true); };
         if (blob.size < 1000) { maybeResumeLive(); return; }
         setBusy(true);
+        setVoicePhase("transcribing"); // KI-038 — STT in flight on PTT
         try {
           const { text } = await postTranscribe(blob, ttsLang);
-          if (text && text.trim()) await send(text);
-          else pushAssistant("Sorry, I couldn't hear that clearly. Please try again.");
+          if (text && text.trim()) {
+            // send() flips voicePhase to "thinking" itself; no need to set here
+            await send(text);
+          } else {
+            pushAssistant("Sorry, I couldn't hear that clearly. Please try again.");
+          }
         } catch (e: unknown) {
           pushAssistant(`Sorry — transcribe error: ${e instanceof Error ? e.message : String(e)}`);
         } finally {
           setBusy(false);
+          setVoicePhase(null);
           maybeResumeLive();
         }
       };
@@ -698,7 +716,7 @@ export default function Page() {
             </div>
             <div ref={scrollRef} className="flex-1 overflow-y-auto scrollbar-thin space-y-4 mb-4 pr-1">
               {messages.map((m) => <Message key={m.id} m={m} />)}
-              {busy && <ThinkingDots />}
+              {(busy || voicePhase) && <ThinkingDots phase={voicePhase} />}
             </div>
           </>
         )}
@@ -1632,15 +1650,24 @@ function ScorecardCard({ sc }: { sc: ScorecardResponse }) {
   );
 }
 
-function ThinkingDots() {
+function ThinkingDots({ phase }: { phase?: null | "transcribing" | "thinking" | "speaking" } = {}) {
+  // KI-038 — phase-labeled status, not just an opaque blob of dots. Users
+  // need to know whether the bot is hearing them ("transcribing"), thinking
+  // about the answer ("thinking"), or about to speak ("speaking").
+  const label = phase === "transcribing"
+    ? "Hearing you…"
+    : phase === "speaking"
+      ? "Speaking…"
+      : "Thinking…";
   return (
     <div className="flex justify-start">
-      <div className="bg-[var(--card)] border border-[var(--border)] rounded-2xl px-4 py-3">
+      <div className="bg-[var(--card)] border border-[var(--border)] rounded-2xl px-4 py-3 flex items-center gap-2.5">
         <div className="flex gap-1.5">
           {[0, 1, 2].map((i) => (
-            <span key={i} className="w-2 h-2 rounded-full bg-[var(--muted-foreground)] opacity-50" style={{ animation: "fade-up 1.2s ease-in-out infinite", animationDelay: `${i * 0.2}s` }} />
+            <span key={i} className="w-2 h-2 rounded-full bg-[var(--primary)] opacity-70" style={{ animation: "fade-up 1.2s ease-in-out infinite", animationDelay: `${i * 0.2}s` }} />
           ))}
         </div>
+        <span className="text-xs text-[var(--muted-foreground)] font-medium">{label}</span>
       </div>
     </div>
   );