feat: KI-039 + KI-040 — single Clear-chat (keep profile) + named profiles

KI-039 — Single Clear-chat button. The previous two-button setup
("Clear chat" / "Start fresh") confused users. Now one button labeled
"Clear chat" wipes the visible conversation but KEEPS the server-side
profile, so the bot doesn't lose context — next turn picks up with the
existing profile loaded. The user-stated rationale: "the LLM still knows
what conversations, what questions have already been answered, and it
can speak in a natural manner."

KI-040 — Named profiles for cross-session identity.

Backend changes:
• backend/profile_store.py (NEW) — JSON-keyed by normalised name.
save_profile / load_profile / list_profiles + is_valid_name.
Files at data/profiles/<slug>.json. Display name preserved inside
each file. Atomic write via .tmp + replace.
• backend/needs_finder.py — Profile dataclass gains `name: Optional[str]`.
GRAPH gets a new slot 0 ("name") that asks "First — what should I
call you?" before age. Free-text, validated 1-50 chars 50%+ alpha.
• backend/orchestrator.py — name-slot special handling:
(a) tolerates conversational prefixes ("I'm Rohit", "My name is",
"call me", "this is") and strips them before storing,
(b) auto-capitalises a sensible display form when the user typed
all-lowercase,
(c) on successful name capture, calls profile_store.load_profile.
If it returns a stored profile with material content, MERGES
every populated field into session.profile, marks every slot
as already-asked, flips free_form_session=True, and short-
circuits with a "Welcome back, <name>!" reply (brain_tag
`needs_finder::welcome_back`) — skipping the full 9-question
walk for returning visitors,
(d) on any other slot capture, persists the updated profile back
to the JSON store so the next visit sees the latest state.

Architecture note (per the user's "embed or JSON?" question): JSON is
the canonical store for name lookup (O(1) deterministic); Chroma's
profile chunk (existing upsert_profile_chunk in profile_rag.py) stays
the retrieval-time context layer (re-embedded on profile change, not
per query). Both layers stay in sync.

Frontend change:
• Two-button Clear chat / Start fresh consolidated to one "Clear chat"
button. Calls handleClearChat(false) — drop_profile stays false.

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

backend/needs_finder.py

@@ -30,6 +30,7 @@ from typing import Any, Optional
 @dataclass
 class Profile:
     """User profile accumulated during fact-find."""
+    name: Optional[str] = None  # KI-040 — humanise + key for cross-session lookup
     age: Optional[int] = None
     dependents: Optional[str] = None  # "self", "self+spouse", "self+spouse+kids", "self+parents", etc.
     income_band: Optional[str] = None  # "under_5L", "5L-10L", "10L-25L", "25L+"
@@ -66,6 +67,14 @@ def _always(p: Profile) -> bool:
 
 
 GRAPH: list[Question] = [
+    Question(
+        id="name",
+        prompt_en="First — what should I call you? I'll save your profile so the next time you visit, you won't have to answer all this again.",
+        prompt_hi="सबसे पहले — आपको क्या कहूँ? आपकी profile save हो जाएगी, तो अगली बार दोबारा सवाल नहीं पूछूँगा।",
+        field="name",
+        is_core=True,
+        # Free-text — no parser; the orchestrator validates 1-50 chars
+    ),
     Question(
         id="age",
         prompt_en="First, your age? (Premium + eligibility + how long you can renew all hinge on this.)",

backend/orchestrator.py

@@ -320,10 +320,73 @@ async def handle_turn(
         # the slot-filler was actually working — see readback summaries in
         # `needs_finder::fact_find_complete` turns).
         fact_find_profile_updates: dict = {}
+        # KI-040 — named-profile return-visit detection. Set when we resolve
+        # a name and find a stored profile for that name; used at the bottom
+        # of this branch to emit a "Welcome back" message instead of the
+        # next slot's question.
+        returning_visitor_greeting: Optional[str] = None
         if session.awaiting_question_id:
             from backend.fact_find_normalizer import is_valid_answer, normalize_answer
             qid = session.awaiting_question_id
-            if not is_valid_answer(user_text):
+            # KI-040 — special handling for the name slot: free-text, no enum.
+            if qid == "name":
+                from backend.profile_store import is_valid_name, load_profile, save_profile
+                raw_name = user_text.strip().strip(".,!?")
+                # 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):
+                        raw_name = raw_name[len(prefix):].strip()
+                        break
+                # Capitalize a sensible display form
+                if raw_name and not any(c.isupper() for c in raw_name):
+                    raw_name = " ".join(w.capitalize() for w in raw_name.split())
+                if is_valid_name(raw_name):
+                    session.update_profile_field("name", raw_name)
+                    fact_find_profile_updates["name"] = raw_name
+                    if qid not in session.profile.asked:
+                        session.profile.asked.append(qid)
+                    session.set_awaiting(None)
+                    if hasattr(session, "_reask_counts"):
+                        session._reask_counts.pop(qid, None)
+                    # Look up an existing profile for this name. If found,
+                    # MERGE its fields into the current empty session so the
+                    # user doesn't repeat the 9-question walk.
+                    stored = load_profile(raw_name)
+                    if stored is not None and any(
+                        getattr(stored, f, None) not in (None, [], "")
+                        for f in ("age", "dependents", "income_band", "primary_goal")
+                    ):
+                        for field_name in (
+                            "age", "dependents", "income_band", "existing_cover_inr",
+                            "primary_goal", "location_tier", "parents_to_insure",
+                            "parents_age_max", "parents_has_ped", "health_conditions",
+                            "budget_band",
+                        ):
+                            val = getattr(stored, field_name, None)
+                            if val not in (None, [], ""):
+                                session.update_profile_field(field_name, val)
+                                fact_find_profile_updates[field_name] = val
+                        # Mark all stored slots as already-asked so next_question
+                        # skips them.
+                        for slot_id in ("age", "dependents", "income_band",
+                                        "existing_cover", "primary_goal", "location",
+                                        "parents_age", "health_conditions", "budget"):
+                            if slot_id not in session.profile.asked:
+                                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?"
+                        )
+                    else:
+                        # New visitor — record an initial profile so subsequent
+                        # turns persist; orchestrator will continue to next slot.
+                        save_profile(raw_name, session.profile, session_id=session_id)
+                else:
+                    ambiguous_or_failed = True
+            elif not is_valid_answer(user_text):
                 ambiguous_or_failed = True
             else:
                 try:
@@ -344,6 +407,14 @@ async def handle_turn(
                         # Reset re-ask counter on success
                         if hasattr(session, "_reask_counts"):
                             session._reask_counts.pop(qid, None)
+                        # KI-040 — persist the updated profile to JSON store
+                        # so next-visit lookup-by-name has the latest data.
+                        if session.profile.name:
+                            try:
+                                from backend.profile_store import save_profile
+                                save_profile(session.profile.name, session.profile, session_id=session_id)
+                            except Exception:
+                                pass
                     else:
                         ambiguous_or_failed = True
 
@@ -359,6 +430,24 @@ async def handle_turn(
                     session.set_awaiting(None)
                     ambiguous_or_failed = False  # no longer a reask situation
 
+        # KI-040 — returning-visitor short-circuit. If we recognised the user's
+        # name and loaded their stored profile, skip directly to the greeting
+        # without picking another fact-find question.
+        if returning_visitor_greeting:
+            return TurnResult(
+                reply_text=returning_visitor_greeting,
+                citations=[],
+                retrieved_chunk_ids=[],
+                brain_used="needs_finder::welcome_back",
+                intent="fact_find",
+                language=language,
+                latency_ms=int((time.time() - t0) * 1000),
+                raw_reply=returning_visitor_greeting,
+                faithfulness_passed=True,
+                blocked=False,
+                profile_updates=fact_find_profile_updates,
+            )
+
         # If the answer didn't normalize, pick the SAME question again (re-ask
         # with a gentle clarifier) instead of moving on with garbage — UNLESS
         # the cap above just kicked in, in which case we move on.

backend/profile_store.py

@@ -0,0 +1,150 @@
+"""Persistent name-keyed profile store.
+
+KI-040 (2026-05-14). Lets returning visitors say their name and have the
+bot recognise them + auto-load their stored profile, so they don't have
+to walk the 9-slot fact-find again.
+
+Architectural answer to the "embed or JSON?" question:
+
+  • JSON (this module) — the canonical store, keyed by normalised name.
+    O(1) lookup, deterministic, human-readable, manually editable.
+  • Chroma vector chunk (existing backend/profile_rag.py) — re-embedded
+    when the profile changes, so retrieval-time the brain sees the
+    user's profile alongside policy chunks for the "what's best for me?"
+    style questions. Embedding cost = once per update, not per query.
+
+Both layers stay in sync: when `save_profile()` is called here, the
+orchestrator also fires `profile_rag.upsert_profile_chunk()` so the
+Chroma side reflects the new state.
+
+Files live under `data/profiles/<normalised-name>.json`. Names are
+normalised to lowercase + alpha-only for the filename so "Rohit" and
+"rohit." both resolve to the same profile. The original (capitalised)
+display name is preserved inside the JSON.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+import time
+from dataclasses import asdict
+from pathlib import Path
+from typing import Optional
+
+from backend.config import settings
+from backend.needs_finder import Profile
+
+_PROFILES_DIR = settings.CORPUS_DIR.parent.parent / "data" / "profiles"
+
+
+def _normalise_name(name: str) -> str:
+    """Lowercase + strip to alphanumerics. 'Rohit Sharma' → 'rohit-sharma'."""
+    if not name:
+        return ""
+    cleaned = re.sub(r"[^a-zA-Z0-9]+", "-", name.strip().lower()).strip("-")
+    return cleaned[:60]  # cap filename length
+
+
+def _path_for(name: str) -> Optional[Path]:
+    slug = _normalise_name(name)
+    if not slug:
+        return None
+    return _PROFILES_DIR / f"{slug}.json"
+
+
+def is_valid_name(text: str) -> bool:
+    """Heuristic name validation. Rejects empty, too long, mostly-non-alpha."""
+    if not text:
+        return False
+    s = text.strip()
+    if not (1 <= len(s) <= 50):
+        return False
+    # At least 60% alphabetic
+    alpha = sum(1 for c in s if c.isalpha())
+    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
+    try:
+        raw = json.loads(p.read_text())
+    except Exception as e:
+        logging.warning("profile_store load failed name=%s: %s", name, e)
+        return None
+    prof_dict = raw.get("profile") or {}
+    valid_fields = set(Profile.__dataclass_fields__.keys())
+    prof_dict = {k: v for k, v in prof_dict.items() if k in valid_fields}
+    try:
+        return Profile(**prof_dict)
+    except Exception as e:
+        logging.warning("profile_store reconstruct failed name=%s: %s", name, 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."""
+    p = _path_for(name)
+    if not p:
+        return False
+    try:
+        _PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+        existing: dict = {}
+        if p.exists():
+            try:
+                existing = json.loads(p.read_text())
+            except Exception:
+                existing = {}
+        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:
+            sessions.append(session_id)
+            sessions = sessions[-20:]  # keep last 20 only
+        payload = {
+            "name_display": (profile.name or name).strip(),
+            "name_slug": _normalise_name(name),
+            "profile": asdict(profile),
+            "first_seen": existing.get("first_seen") or now_iso,
+            "last_seen": now_iso,
+            "sessions": sessions,
+        }
+        tmp = p.with_suffix(".json.tmp")
+        tmp.write_text(json.dumps(payload, indent=2, default=str))
+        tmp.replace(p)
+        return True
+    except Exception as e:
+        logging.warning("profile_store save failed name=%s: %s", name, e)
+        return False
+
+
+def list_profiles() -> list[dict]:
+    """Return summary of all stored profiles — used by the admin Profile +
+    Visitor Log view. One entry per file."""
+    if not _PROFILES_DIR.exists():
+        return []
+    out: list[dict] = []
+    for p in sorted(_PROFILES_DIR.glob("*.json")):
+        try:
+            raw = json.loads(p.read_text())
+            out.append({
+                "name_display": raw.get("name_display"),
+                "name_slug": raw.get("name_slug"),
+                "first_seen": raw.get("first_seen"),
+                "last_seen": raw.get("last_seen"),
+                "session_count": len(raw.get("sessions") or []),
+                "profile_complete_fields": sum(
+                    1 for v in (raw.get("profile") or {}).values()
+                    if v not in (None, "", [], 0)
+                ),
+            })
+        except Exception:
+            continue
+    return out

frontend/src/app/page.tsx

@@ -691,16 +691,18 @@ export default function Page() {
           <EmptyState onSuggest={(q) => send(q)} coverage={coverage} t={t} />
         ) : (
           <>
-            {/* KI-020 / KI-039 — single Clear-chat control. One click wipes
-                the visible chat AND clears server-side profile AND issues a
-                fresh session id. Two-button variant was confusing per user
-                feedback. */}
+            {/* KI-020 / KI-039 / KI-040 — single Clear-chat control. One
+                click wipes the visible chat history but KEEPS the server-side
+                profile so the bot doesn't have to re-fact-find the user. The
+                bot will pick up with the existing profile on the next turn.
+                (A named-profile feature for fully-different identities is on
+                the roadmap — see backend/profile_store.py.) */}
             <div className="flex items-center justify-end gap-2 mb-2 text-[11px]">
               <button
-                onClick={() => handleClearChat(true)}
+                onClick={() => handleClearChat(false)}
                 disabled={busy}
-                className="px-2 py-1 rounded-md border border-[var(--border)] text-[var(--muted-foreground)] hover:text-rose-600 hover:border-rose-400 disabled:opacity-40 transition"
-                title="Wipe this conversation — clears chat history, profile, and starts a fresh session"
+                className="px-2 py-1 rounded-md border border-[var(--border)] text-[var(--muted-foreground)] hover:text-[var(--foreground)] hover:border-[var(--primary)] disabled:opacity-40 transition"
+                title="Clear the visible chat. Your profile is preserved so the bot picks up where it left off."
               >
                 Clear chat
               </button>