feat(profile + voice): KI-059 / KI-060 / KI-061 / KI-062 — opening-turn name capture, looser VAD silence, personalized welcome-back, unique persona ID

Four user-testing fixes landed in one commit.

KI-059 — Catch name disclosed in opening message
═══════════════════════════════════════════════════════════════
User typed "Hi this is Rohit" as the very first message; bot still asked
"what should I call you?". Now an opening turn that contains a self-
introduction routes straight into the name-slot handler.

- New `_contains_self_introduction(text)` helper. Strips leading
greetings ("hi", "hello", "hey", "namaste", "yo") then matches
"I'm X" / "I am X" / "this is X" / "my name is X" / "name is X" /
"call me X" / "name's X".
- Tested 10/10 (positive + negative cases pass).
- When detected on turn 0, orchestrator synthesises
`session.awaiting_question_id = "name"` so the existing name-slot
pipeline (extract, save, welcome-back lookup) runs.
- Name-handler prefix loop widened: now strips leading
"hi[,]? " / "hello[,]? " / "hey[,]? " / etc. BEFORE the
"this is " / "i'm " / etc. loop, so "Hi, this is Rohit" → "Rohit".

KI-060 — Live VAD silence threshold loosened
═══════════════════════════════════════════════════════════════
User report: "small background noise is making the live stream auto submit.
Even if I pause for a second before I can continue speaking."

Root cause: KI-057 made the noise gate work correctly, which exposed an
underlying problem — `silenceEndFrames: 40` (~640 ms of silence) was too
aggressive for natural mid-sentence pauses. Bumped to 90 (~1.5 s). Single
config change in useLiveConversation.ts DEFAULTS.

KI-061 — Personalized welcome-back greeting
═══════════════════════════════════════════════════════════════
Previously: "Welcome back, Rohit! I've loaded your profile from last time."
Now also lists what's on file and what's missing, so the user feels
remembered AND any gap can be filled before recommending.

- `_format_known_profile_summary(profile)` returns a comma-joined
rundown ("age 34, covering you+spouse, income 10-25L, looking
for first health policy").
- `_format_missing_slots(profile)` returns human-readable labels
for high-value gaps (age, dependents, income, primary_goal,
parents' health, budget). Minor slots (location, existing cover,
health conditions) deliberately excluded to keep the greeting
focused.
- Greeting composes both: "Welcome back, X! Here's what I have on
file: ... We never got around to ... — happy to fill that in or
jump straight to a recommendation."

KI-062 — Full name + unique persona ID
═══════════════════════════════════════════════════════════════
User: "it should get my full name, Rohit Sar, for example, so that it's
easier to identify. Unique user / persona ID should also be created. That
is a combination of not just the name, which can be similar, but all the
other data points that we also collect."

- Name regex widened from 1-2 words to 1-4 words. "Rohit Sar" and
"Anjali Devi Kumar" now capture fully.
- New `compute_persona_id(profile)` in profile_store. Returns a
12-char sha1 over normalised name + age + dependents + income_band
+ location_tier + parents_age_max. Two users named "Rohit" with
different identity fields resolve to distinct IDs (verified: ids
d4ea9d29... vs c49f6838... in roundtrip test).
- `save_profile` now keys files by persona_id when there's enough
signal; falls back to name-slug for first-visit (only name known).
- `load_profile(name, persona_id=...)` does a 3-tier lookup: direct
persona-id hit → legacy name-slug → directory scan for any
persona-id-keyed file whose stored display name matches.
- Legacy name-slug file cleanup on save: when an identity is finally
resolved, the older same-name file's session history is folded
forward into the new persona-id file, then the legacy file is
unlinked. No orphan files; session lineage preserved.

Verification
═══════════════════════════════════════════════════════════════
- py_compile both backend files: OK
- 10/10 inline cases on _contains_self_introduction
- persona_id distinct for two different-identity Rohits + stable on replay
- save_profile + load_profile by persona_id roundtrip
- npx tsc --noEmit (frontend): 0 errors

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

backend/orchestrator.py

@@ -235,6 +235,93 @@ def _family_aware_opener(user_text: str, fallback: str) -> Optional[str]:
     return pool[idx]
 
 
+_SELF_INTRO_RE = re.compile(
+    # KI-062 (2026-05-15) — widened from 1-2 words to 1-4 words so full
+    # names like "Rohit Sar" or "Anjali Devi Kumar" get captured.
+    r"\b(?:i'?m|i\s+am|this\s+is|my\s+name\s+is|name\s+is|call\s+me|name'?s)\s+"
+    r"([a-zA-Z][a-zA-Z'\-]{1,30}"
+    r"(?:\s+[a-zA-Z][a-zA-Z'\-]{1,30}){0,3})\b",
+    re.IGNORECASE,
+)
+
+# KI-059 (2026-05-15) — leading greeting tokens to ignore so "Hi this is X"
+# and "Hello, my name is X" reach the introduction phrase.
+_GREETING_LEAD = re.compile(
+    r"^\s*(?:hi|hello|hey|namaste|yo|hola)[,!.\s]+",
+    re.IGNORECASE,
+)
+
+
+def _contains_self_introduction(text: str) -> bool:
+    """True if the message volunteers a name via "I'm X" / "this is X" /
+    "my name is X" / "call me X" — with or without a greeting prefix.
+
+    Used by KI-059 to detect when a user has supplied their name in the
+    very first turn so we don't ask "what should I call you?" right after
+    they told us.
+    """
+    if not text:
+        return False
+    stripped = _GREETING_LEAD.sub("", text.strip())
+    return bool(_SELF_INTRO_RE.search(stripped))
+
+
+# KI-061 (2026-05-15) — human-readable summaries for the welcome-back
+# greeting. Each tuple is (field name on Profile, label, formatter).
+_KNOWN_FIELD_FORMATTERS: tuple[tuple[str, str, "callable"], ...] = (
+    ("age", "age", lambda v: f"{v}"),
+    ("dependents", "covering", lambda v: str(v).replace("self+", "you+").replace("+", " + ")),
+    ("income_band", "income band", lambda v: str(v)),
+    ("existing_cover_inr", "existing cover", lambda v: f"₹{v:,}" if isinstance(v, int) else str(v)),
+    ("primary_goal", "looking for", lambda v: str(v).replace("_", " ")),
+    ("location_tier", "city tier", lambda v: str(v)),
+    ("parents_age_max", "parents' age", lambda v: f"oldest {v}"),
+    ("health_conditions", "health conditions", lambda v: ", ".join(v) if isinstance(v, list) and v else None),
+    ("budget_band", "budget", lambda v: str(v)),
+)
+
+
+def _format_known_profile_summary(profile) -> str:
+    """Return a comma-separated rundown of what we already know, e.g.
+    'age 34, covering you + spouse, income ₹10-25L, looking for first
+    health policy'. Returns '' if nothing meaningful is stored."""
+    parts: list[str] = []
+    for field_name, label, fmt in _KNOWN_FIELD_FORMATTERS:
+        val = getattr(profile, field_name, None)
+        if val in (None, "", []):
+            continue
+        try:
+            rendered = fmt(val)
+        except Exception:
+            rendered = str(val)
+        if rendered:
+            parts.append(f"{label} {rendered}")
+    return ", ".join(parts)
+
+
+_HELPFUL_GAP_LABELS = {
+    "age": "your age",
+    "dependents": "who you're covering",
+    "income_band": "your income band",
+    "primary_goal": "what you're shopping for",
+    "parents_age_max": "your parents' health context",
+    "budget_band": "your budget",
+}
+
+
+def _format_missing_slots(profile) -> list[str]:
+    """Return human-readable labels for the high-value slots we never
+    captured. Limited to the ones that genuinely shape a recommendation
+    — minor slots (location, existing_cover, health_conditions) are
+    skipped to keep the welcome-back focused."""
+    missing = []
+    for field_name, label in _HELPFUL_GAP_LABELS.items():
+        val = getattr(profile, field_name, None)
+        if val in (None, "", []):
+            missing.append(label)
+    return missing
+
+
 def _pick_opener(
     user_text: str,
     session_id: Optional[str],
@@ -500,6 +587,21 @@ async def handle_turn(
         # of this branch to emit a "Welcome back" message instead of the
         # next slot's question.
         returning_visitor_greeting: Optional[str] = None
+
+        # KI-059 (2026-05-15) — opening-turn name capture. If the user
+        # volunteered a name in their FIRST message ("Hi this is Rohit",
+        # "I'm Anjali", "My name is Ravi") before we asked, route it into
+        # the name-slot handler below so the existing extract + save +
+        # welcome-back logic fires — instead of asking "what should I
+        # call you?" right after they told us. Pre-condition: not yet
+        # awaiting any slot, no name on the profile, and not in
+        # free-form session.
+        if (not session.awaiting_question_id
+                and not session.profile.name
+                and not session.free_form_session
+                and _contains_self_introduction(user_text)):
+            session.set_awaiting("name")
+
         if session.awaiting_question_id:
             from backend.fact_find_normalizer import is_valid_answer, normalize_answer
             qid = session.awaiting_question_id
@@ -507,6 +609,15 @@ async def handle_turn(
             if qid == "name":
                 from backend.profile_store import is_valid_name, load_profile, save_profile
                 raw_name = user_text.strip().strip(".,!?")
+                # KI-059 — strip a leading greeting + comma so "Hi, this is
+                # Rohit" / "Hello I'm Anjali" reduces to the introduction
+                # phrase the next loop expects.
+                for greet in ("hi there ", "hello there ", "hey there ",
+                              "hi, ", "hello, ", "hey, ",
+                              "hi ", "hello ", "hey ", "namaste ", "yo "):
+                    if raw_name.lower().startswith(greet):
+                        raw_name = raw_name[len(greet):].strip()
+                        break
                 # Tolerate "I'm Rohit" / "My name is Rohit" / "call me Rohit"
                 for prefix in ("i'm ", "i am ", "my name is ", "name is ", "call me ", "this is "):
                     if raw_name.lower().startswith(prefix):
@@ -550,11 +661,36 @@ async def handle_turn(
                                 session.profile.asked.append(slot_id)
                         session.free_form_session = True
                         session._flush()
-                        returning_visitor_greeting = (
-                            f"Welcome back, {raw_name}! I've loaded your profile from last time. "
-                            "Want me to suggest some policies that fit your situation, or do "
-                            "you have a specific question in mind?"
-                        )
+                        # KI-061 (2026-05-15) — personalized welcome-back:
+                        # summarize what's on file, call out helpful gaps,
+                        # offer next step. So the returning visitor sees
+                        # the bot remembers them precisely, and any missing
+                        # info can be filled before recommending.
+                        known_summary = _format_known_profile_summary(stored)
+                        missing_labels = _format_missing_slots(stored)
+                        parts = [f"Welcome back, {raw_name}!"]
+                        if known_summary:
+                            parts.append(
+                                f"Here's what I have on file from your last visit: {known_summary}."
+                            )
+                        if missing_labels:
+                            if len(missing_labels) == 1:
+                                gap_phrase = missing_labels[0]
+                            elif len(missing_labels) == 2:
+                                gap_phrase = " and ".join(missing_labels)
+                            else:
+                                gap_phrase = ", ".join(missing_labels[:-1]) + f", and {missing_labels[-1]}"
+                            parts.append(
+                                f"We never got around to {gap_phrase} — happy to fill that in "
+                                "so I can grade policies more precisely, or you can jump straight "
+                                "to a recommendation or any specific question."
+                            )
+                        else:
+                            parts.append(
+                                "Looks like we have everything we need — want me to suggest some "
+                                "policies that fit, or do you have a specific question in mind?"
+                            )
+                        returning_visitor_greeting = " ".join(parts)
                     else:
                         # New visitor — record an initial profile so subsequent
                         # turns persist; orchestrator will continue to next slot.

backend/profile_store.py

@@ -25,6 +25,7 @@ display name is preserved inside the JSON.
 
 from __future__ import annotations
 
+import hashlib
 import json
 import logging
 import re
@@ -47,7 +48,38 @@ def _normalise_name(name: str) -> str:
     return cleaned[:60]  # cap filename length
 
 
-def _path_for(name: str) -> Optional[Path]:
+# KI-062 (2026-05-15) — identity-defining fields used to disambiguate two
+# users with the same display name. Order matters for hash stability.
+_PERSONA_ID_FIELDS: tuple[str, ...] = (
+    "age", "dependents", "income_band", "location_tier", "parents_age_max",
+)
+
+
+def compute_persona_id(profile: Profile) -> str:
+    """Return a 12-char hash blending the user's normalised name with their
+    identity-defining profile fields. Two users named 'Rohit' but with
+    different age/dependents/location resolve to different persona IDs.
+
+    Returns '' if there's not enough signal (no name AND no identity
+    fields). Caller falls back to name-only slug in that case.
+
+    KI-062 (2026-05-15).
+    """
+    parts = [_normalise_name(profile.name or "")]
+    for f in _PERSONA_ID_FIELDS:
+        v = getattr(profile, f, None)
+        parts.append("" if v in (None, "", []) else str(v).strip().lower())
+    if not any(parts):
+        return ""
+    blob = "|".join(parts).encode("utf-8")
+    return hashlib.sha1(blob).hexdigest()[:12]
+
+
+def _path_for(name: str, *, persona_id: Optional[str] = None) -> Optional[Path]:
+    """Resolve the JSON file path. Prefers persona_id (KI-062) when given,
+    falling back to the name slug for legacy lookups."""
+    if persona_id:
+        return _PROFILES_DIR / f"{persona_id}.json"
     slug = _normalise_name(name)
     if not slug:
         return None
@@ -66,19 +98,13 @@ def is_valid_name(text: str) -> bool:
     return alpha / max(1, len(s)) >= 0.5
 
 
-def load_profile(name: str) -> Optional[Profile]:
-    """Return the stored Profile for `name`, or None if no record exists.
-
-    Future-proofs against Profile schema drift — any persisted fields that no
-    longer exist on the Profile dataclass are silently dropped.
-    """
-    p = _path_for(name)
-    if not p or not p.exists():
-        return None
+def _load_from_path(p: Path) -> Optional[Profile]:
+    """Read a profile file path → Profile. Drops persisted fields that no
+    longer exist on the Profile dataclass (schema-drift safety)."""
     try:
         raw = json.loads(p.read_text())
     except Exception as e:
-        logging.warning("profile_store load failed name=%s: %s", name, e)
+        logging.warning("profile_store load failed path=%s: %s", p, e)
         return None
     prof_dict = raw.get("profile") or {}
     valid_fields = set(Profile.__dataclass_fields__.keys())
@@ -86,13 +112,52 @@ def load_profile(name: str) -> Optional[Profile]:
     try:
         return Profile(**prof_dict)
     except Exception as e:
-        logging.warning("profile_store reconstruct failed name=%s: %s", name, e)
+        logging.warning("profile_store reconstruct failed path=%s: %s", p, e)
         return None
 
 
-def save_profile(name: str, profile: Profile, *, session_id: Optional[str] = None) -> bool:
-    """Persist `profile` keyed by `name`. Returns True on success."""
+def load_profile(name: str, *, persona_id: Optional[str] = None) -> Optional[Profile]:
+    """Return the stored Profile for `name` (and optional `persona_id`).
+
+    KI-062 (2026-05-15) lookup order:
+      1. If `persona_id` given, try that file first.
+      2. Try the name-slug file (legacy + first-visit path before
+         identity fields are known).
+      3. If both miss but the name slug is set, scan the directory for
+         any persona-id-keyed file whose stored name matches — handles
+         the case where the user introduced themselves by name but no
+         persona ID is known yet client-side.
+    """
+    # 1. Direct persona-id hit
+    if persona_id:
+        p = _path_for(name, persona_id=persona_id)
+        if p and p.exists():
+            return _load_from_path(p)
+    # 2. Legacy / first-visit name-slug file
     p = _path_for(name)
+    if p and p.exists():
+        return _load_from_path(p)
+    # 3. Scan for any persona-id file whose stored display-name matches
+    slug = _normalise_name(name)
+    if slug and _PROFILES_DIR.exists():
+        for cand in _PROFILES_DIR.glob("*.json"):
+            try:
+                raw = json.loads(cand.read_text())
+                if _normalise_name(raw.get("name_display") or "") == slug:
+                    return _load_from_path(cand)
+            except Exception:
+                continue
+    return None
+
+
+def save_profile(name: str, profile: Profile, *, session_id: Optional[str] = None) -> bool:
+    """Persist `profile`. KI-062 (2026-05-15): files are keyed by
+    `compute_persona_id(profile)` when there's enough signal so two users
+    named 'Rohit' with different age/location don't overwrite each other.
+    Falls back to the name slug when persona_id can't be derived.
+    """
+    persona_id = compute_persona_id(profile)
+    p = _path_for(name, persona_id=persona_id) if persona_id else _path_for(name)
     if not p:
         return False
     try:
@@ -103,6 +168,22 @@ def save_profile(name: str, profile: Profile, *, session_id: Optional[str] = Non
                 existing = json.loads(p.read_text())
             except Exception:
                 existing = {}
+        # KI-062 — also clean up any older same-name file that was saved
+        # before we had enough identity signal to disambiguate. We move
+        # its session history into the new file rather than orphaning.
+        if persona_id:
+            legacy = _path_for(name)
+            if legacy and legacy.exists() and legacy.resolve() != p.resolve():
+                try:
+                    leg_raw = json.loads(legacy.read_text())
+                    legacy_sessions = list(leg_raw.get("sessions") or [])
+                    existing.setdefault("sessions", [])
+                    for s in legacy_sessions:
+                        if s not in existing["sessions"]:
+                            existing["sessions"].append(s)
+                    legacy.unlink()
+                except Exception:
+                    pass
         now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
         sessions = list(existing.get("sessions") or [])
         if session_id and session_id not in sessions:
@@ -111,6 +192,7 @@ def save_profile(name: str, profile: Profile, *, session_id: Optional[str] = Non
         payload = {
             "name_display": (profile.name or name).strip(),
             "name_slug": _normalise_name(name),
+            "persona_id": persona_id,  # KI-062
             "profile": asdict(profile),
             "first_seen": existing.get("first_seen") or now_iso,
             "last_seen": now_iso,

frontend/src/lib/useLiveConversation.ts

@@ -5,6 +5,8 @@
  *
  * KI-044 (2026-05-14) — PCM pre-roll via AudioWorklet.
  * KI-057 (2026-05-15) — Noise-robust VAD + flush-on-stop.
+ * KI-060 (2026-05-15) — Silence-end window lengthened (40 → 90 frames,
+ *   ~640 ms → ~1.5 s) so natural mid-sentence pauses don't auto-submit.
  *
  * Why KI-057 was needed
  * --------------------------------------------------------------------
@@ -93,7 +95,13 @@ const DEFAULTS = {
   // don't open a segment. KI-044's preroll buffer still captures the
   // first phoneme since we look back 300 ms.
   speechStartFrames: 3,
-  silenceEndFrames: 40, // ~640 ms of silence to declare utterance end
+  // KI-060 (2026-05-15) — bumped 40 → 90 (~1.5 s of silence) so a
+  // natural mid-sentence pause doesn't auto-close the segment.
+  // After KI-057 made noise correctly NOT keep the segment alive,
+  // the underlying silence-end timer was exposed as too aggressive —
+  // users reported that pausing for ~1 s between phrases caused the
+  // bot to submit prematurely.
+  silenceEndFrames: 90,
   minUtteranceMs: 400,
   // KI-044 — How much pre-trigger PCM we keep in the rolling buffer.
   // 300 ms is generous; covers the ~80 ms VAD latency + ~100 ms of