feat!: remove cross-session profile recall (ADR-043) — net −3700 LOC

Sessions are now in-memory only. ADR-041's name-slug + persona_id
two-tier on-disk store and ADR-042 v3+v4's two-fact gate + extended
extractors are removed entirely. Closing the tab discards the profile.

CONTEXT
─────────────────────────────────────────────────────────────────────
Two-week arc of recall hardening (ADR-041 → KI-196 → Bug #25 → Bug #26
→ ADR-042 v1 → v2 → v3 → v4) kept exposing new failure modes. Each
pass was a real bug class, but after v4 the live audit still showed
seeded-test failures because the name-slug pointer was being
overwritten between tests — the structural truth a name-only key
cannot safely disambiguate two visitors who share a name. The
workarounds were accumulating without converging.

Cost/benefit was wrong for an insurance-shopping product (rare-
purchase, return sessions uncommon): ~1500 LOC + 100+ profile JSONs +
2 ADRs + 5 test files + ongoing audit-time state drift, for a feature
whose value is "the bot remembers you next visit." Minimum-data-
retention is a stronger story.

REMOVED
─────────────────────────────────────────────────────────────────────
- backend/profile_store.py (delete)
- backend/profile_persistence.py (delete)
- backend/profile_rag.py (delete)
- backend/session_state.py: rehydrate_by_name, apply_pending_recall,
_AGE_HINT_RE, _extract_*_from_text (4), _parse_user_text_facts,
_LOCATION_TIER_MAP, _RECALL_SUMMARY_FIELDS, pending_profile_recall /
recall_probe_done / recall_match_deferred fields on SessionState
- backend/single_brain.py: _affirm_or_deny, _RECALL_AFFIRM_TOKENS,
_RECALL_DENY_TOKENS, _RECALL_AFFIRM_PHRASES, _RECALL_DENY_PHRASES,
_RECALL_TOKEN_RE, recall_block + restored_block + pending_recall /
recall_applied params on _system_instruction, the ~70-line recall
prelude in handle_turn, the end-of-turn auto_persist_session call
- backend/main.py: /api/profile/recall-by-name endpoint + models,
pre-turn name snapshot, _every_filled_slot_was_set_this_turn,
_FEATURE_B_SLOT_LIST, the auto_persist_session call + returning-
user detector, the /api/profile save_profile + upsert_profile_chunk
side-effects
- backend/brain_tools.py: record_policy_event import in
mark_recommendation — replaced by an inline in-memory mutation of
session.profile.shown_policies
- backend/admin.py: /api/admin/profiles + /api/admin/persona-drift +
/api/admin/recommendation-history converted to read from
session_state._sessions (live in-memory) rather than walking
40-data/profiles/*.json. _LazyProfilesDir + _PROFILES_DIR_FOR_DRIFT
+ _resolve_profiles_dir deleted. /api/profile/select +
/api/profile/reject rewritten to mutate session.profile only
- frontend/src/lib/api.ts: postProfileRecallByName +
RecallByNameResponse
- 40-data/profiles/: directory deleted from repo + disk (rm -r + git rm)
- tests/test_bug2526_recall_and_reconstruct.py (delete)
- tests/test_bug45_chat_profile_persistence.py (delete)
- tests/test_profile_rag_isolation.py (delete)
- tests/test_profile_recall_session_isolation.py (delete)
- tests/test_returning_user_recall_singlebrain.py (delete)

KEPT
─────────────────────────────────────────────────────────────────────
- SessionState.profile (in-memory, 1h idle TTL)
- Bug #26 STATE-RECOVERY from chat_history (in-session resilience,
never reads disk)
- ADR-042's sticky-session retry policy (independent of recall)
- ADR-042's admin LLM Chain refresh wiring / KI-296 (independent)
- tests/test_session_no_disk_persistence.py (docstring updated)

DOCS
─────────────────────────────────────────────────────────────────────
- New: 70-docs/60-decisions/ADR-043-remove-cross-session-recall.md
- ADR-041 marked SUPERSEDED by ADR-043
- ADR-042 marked PARTIALLY SUPERSEDED (sticky-retry + admin refresh
retained; recall portions retired)
- README §2.1 user-journey diagram: Welcome-Back branch removed
- README §2.2 building-blocks diagram + prose: Profile labeled
"in-memory only"
- README §2.3 functional-abstraction diagram: P3 recall_by_name +
D3 read_user_profile dropped; linkStyle indices renumbered
- README §2.6: full rewrite — new in-memory-only diagram + the
"why no cross-session recall" rationale
- README §2.7: 40-data/profiles line removed
- README §3.6 + §3.7: in-session state-recovery only; stored-vs-live
table updated
- README §6 repo map: deleted modules removed
- CLAUDE.md "Session & profile lifecycle": rewritten for ADR-043

VERIFY
─────────────────────────────────────────────────────────────────────
- py_compile clean across every backend/*.py
- import-time clean for every backend.* module under .venv/bin/python
- grep for every removed symbol (profile_store / profile_persistence /
profile_rag / rehydrate_by_name / apply_pending_recall /
try_recall_by_name / extract_potential_name / pending_profile_recall
/ recall_match_deferred / _RECALL_* / _affirm_or_deny / _extract_*
/ _AGE_HINT_RE / _LOCATION_TIER_MAP / record_policy_event /
_LazyProfilesDir / _PROFILES_DIR_FOR_DRIFT) — zero active code refs

NET DIFF: −4,358 / +626 (~3,700 LOC net removal)

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

40-data/profiles/62690d7db881.json

@@ -1,38 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "62690d7db881",
-  "profile": {
-    "name": "Rohit",
-    "age": 34,
-    "dependents": "self+spouse+kids",
-    "income_band": null,
-    "existing_cover_inr": null,
-    "primary_goal": null,
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "desired_sum_insured_inr": null,
-    "health_conditions": [],
-    "copay_pct": null,
-    "family_medical_history": [],
-    "smoker": null,
-    "asked": [
-      "name",
-      "age",
-      "dependents",
-      "location_tier"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-16T06:41:30Z",
-  "last_seen": "2026-05-16T06:41:30Z",
-  "sessions": [
-    "sessA_7d9d11fb"
-  ]
-}

40-data/profiles/7f227bef08d1.json

@@ -1,35 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "7f227bef08d1",
-  "profile": {
-    "name": "Rohit",
-    "age": null,
-    "dependents": null,
-    "income_band": null,
-    "existing_cover_inr": null,
-    "primary_goal": null,
-    "location_tier": null,
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "health_conditions": [],
-    "asked": [
-      "name"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-14T23:24:52Z",
-  "last_seen": "2026-05-15T03:36:22Z",
-  "sessions": [
-    "ephem_1",
-    "4556ffba-ef6c-4035-8c67-ce806e681fa7",
-    "probe_ki151_t1",
-    "ki151_smoke_1",
-    "ki158_walk_001"
-  ]
-}

40-data/profiles/93b74ab9ae9f.json

@@ -1,41 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "93b74ab9ae9f",
-  "profile": {
-    "name": "Rohit",
-    "age": 34,
-    "dependents": "self+spouse+kids",
-    "income_band": "18L",
-    "existing_cover_inr": null,
-    "primary_goal": "first_buy",
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "desired_sum_insured_inr": null,
-    "health_conditions": [],
-    "copay_pct": null,
-    "family_medical_history": [],
-    "smoker": null,
-    "asked": [
-      "name",
-      "age",
-      "dependents",
-      "location_tier",
-      "income_band",
-      "primary_goal"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-16T06:41:30Z",
-  "last_seen": "2026-05-16T06:42:12Z",
-  "sessions": [
-    "sessA_7d9d11fb",
-    "sessB_595c9c88"
-  ]
-}

40-data/profiles/9b1da84bb052.json

@@ -1,44 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "9b1da84bb052",
-  "profile": {
-    "name": "Rohit",
-    "age": 29,
-    "dependents": "self",
-    "income_band": "under_5L",
-    "existing_cover_inr": 500000,
-    "primary_goal": "first_buy",
-    "location_tier": null,
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": "under_15k",
-    "health_conditions": [],
-    "asked": [
-      "name",
-      "location",
-      "health_conditions"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-15T03:36:34Z",
-  "last_seen": "2026-05-15T03:51:17Z",
-  "sessions": [
-    "ki158_walk_001",
-    "ki155-test-1",
-    "ki158_verify_001",
-    "ki155-test-2",
-    "ki155-test-3",
-    "ki155-test-4",
-    "ki155-test-5",
-    "ki155-final-1",
-    "ki155-final-2",
-    "ki155-final-3",
-    "ki155-final-4",
-    "ki155-final-5"
-  ]
-}

40-data/profiles/9f23a75fc19e.json

@@ -1,35 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "9f23a75fc19e",
-  "profile": {
-    "name": "Rohit",
-    "age": 29,
-    "dependents": "self",
-    "income_band": "under_5L",
-    "existing_cover_inr": 500000,
-    "primary_goal": "first_buy",
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": "30k_60k",
-    "health_conditions": [],
-    "asked": [
-      "name",
-      "location",
-      "health_conditions",
-      "budget"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-15T03:36:41Z",
-  "last_seen": "2026-05-15T03:48:34Z",
-  "sessions": [
-    "ki158_walk_001",
-    "ki158_verify_001"
-  ]
-}

40-data/profiles/README.md

@@ -1,67 +0,0 @@
-# `data/profiles/` — Named-profile JSON store
-
-Persistent name-keyed profile store introduced by **KI-040 (2026-05-14)**. Lets a returning visitor say their name and have the bot recognise them + auto-load the stored profile, so they don't have to walk the 9-slot fact-find again.
-
-Canonical store: `backend/profile_store.py`. ADR (deferred — code self-documents).
-
-## File layout
-
-```
-data/profiles/
-└── <normalised-name>.json     (one file per user)
-```
-
-- **Filename slug:** lowercase + alpha-only of the user's first name. `"Rohit"` and `"rohit."` both resolve to `rohit.json`.
-- **Inside the file:** the original capitalised display name is preserved.
-
-## JSON shape
-
-```json
-{
-  "display_name": "Rohit",
-  "first_seen": "2026-05-14T09:12:33Z",
-  "last_seen":  "2026-05-14T22:41:08Z",
-  "sessions":   ["sess_abc…", "sess_def…"],
-  "profile": {
-    "age": 32,
-    "dependents": "spouse+1_child",
-    "city_tier": "metro",
-    "...": "..."
-  }
-}
-```
-
-Schema: `profile` mirrors the 9-slot `GRAPH` in `backend/needs_finder.py`. Everything else is bookkeeping.
-
-## Two-layer sync
-
-| Layer | Purpose | Where |
-| --- | --- | --- |
-| JSON (this folder) | Canonical, O(1) name-keyed lookup, deterministic, human-readable, manually editable. | `backend/profile_store.py::save_profile` |
-| Chroma vector chunk | Re-embedded on every save so the brain sees the profile alongside policy chunks at retrieval time — powers "what's best for me?" questions. | `backend/profile_rag.py::upsert_profile_chunk` |
-
-Both stay in sync: `save_profile()` fires the Chroma upsert in the same call. Embedding cost is once per update, not per query.
-
-## Why JSON, not Chroma-only
-
-The original design considered embedding-only. The "why JSON" trade-offs:
-
-- **Deterministic name lookup.** `Rohit` → `rohit.json` is exact; vector search is approximate and can collide on common first names.
-- **Human-readable.** A BFSI auditor can `cat` the file and see the full profile.
-- **Manually editable.** Quick repair without a re-embed pipeline.
-- **No HNSW bloat exposure.** Profile updates do not touch the policy vector store ([ADR-029](../70-docs/60-decisions/ADR-029-hnsw-bloat-tripwire.md)).
-
-The Chroma chunk is purely a retrieval-time view of the canonical JSON.
-
-## Privacy + retention
-
-- Profiles are local to the deployed instance. No third-party share.
-- Per [ADR-010](../70-docs/60-decisions/ADR-010-secret-handling.md), the folder is not exposed via the HTTP API except through the user's own `session_id`.
-- The folder is committed empty (placeholder) — actual profiles are runtime artefacts.
-
-## Related
-
-- `backend/profile_store.py` — the canonical store implementation
-- `backend/profile_extractor.py` + [ADR-022](../70-docs/60-decisions/ADR-022-conversational-profile-updates.md) — how conversational asides flow into the profile
-- `backend/profile_rag.py` — the embedding mirror
-- `backend/needs_finder.py::GRAPH` — the 9-slot schema the `profile` block conforms to

40-data/profiles/asha.json

@@ -1,83 +0,0 @@
-{
-  "name_display": "Asha",
-  "name_slug": "asha",
-  "persona_id": "ca28dcb8ed8b",
-  "profile": {
-    "name": "Asha",
-    "age": 35,
-    "dependents": "self+spouse",
-    "income_band": "10L-25L",
-    "existing_cover_inr": null,
-    "primary_goal": "first_buy",
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "desired_sum_insured_inr": null,
-    "health_conditions": [
-      "none"
-    ],
-    "copay_pct": 0,
-    "family_medical_history": [],
-    "smoker": null,
-    "asked": [
-      "copay_pct"
-    ],
-    "free_form_session": false,
-    "shown_policies": [
-      {
-        "policy_slug": "royal-sundaram__multiplier",
-        "insurer": "royal-sundaram",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 1
-      },
-      {
-        "policy_slug": "niva-bupa__reassure-3",
-        "insurer": "niva-bupa",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 2
-      },
-      {
-        "policy_slug": "care__supreme",
-        "insurer": "care",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 2
-      }
-    ],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-16T13:12:45Z",
-  "last_seen": "2026-05-16T19:57:41Z",
-  "sessions": [
-    "t_8f24225c",
-    "t_e9ffee10",
-    "t_a40eaba0",
-    "t_15bcbab1",
-    "t_ea2b6e61",
-    "t_f8bf16d3",
-    "t_02f7e949",
-    "t_3fa40ae8",
-    "t_3aa7f39f",
-    "t_5bcb0d4c",
-    "t_8874c358",
-    "t_3c159933",
-    "t_bfb35b97",
-    "t_a5549a35",
-    "t_6602f010",
-    "t_7f5224e7",
-    "t_a220f19b",
-    "t_fd487de1",
-    "t_29a9cb78",
-    "t_1541ede6"
-  ],
-  "recall_pointer": true,
-  "points_to_persona_id": "ca28dcb8ed8b"
-}

40-data/profiles/c7b4ef2af903.json

@@ -1,46 +0,0 @@
-{
-  "name_display": "X7 Smoke User",
-  "name_slug": "x7-smoke-user",
-  "persona_id": "c7b4ef2af903",
-  "profile": {
-    "name": "X7 Smoke User",
-    "age": null,
-    "dependents": null,
-    "income_band": null,
-    "existing_cover_inr": null,
-    "primary_goal": null,
-    "location_tier": null,
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "health_conditions": [],
-    "asked": [],
-    "free_form_session": false,
-    "shown_policies": [
-      {
-        "policy_slug": "care-supreme",
-        "insurer": "care_health",
-        "event_at": "2026-05-15T08:13:05Z",
-        "session_id": "x7-smoke-25746",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 4
-      },
-      {
-        "policy_slug": "star-comprehensive",
-        "insurer": "star_health",
-        "event_at": "2026-05-15T08:13:05Z",
-        "session_id": "x7-smoke-25746",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 4
-      }
-    ],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-15T08:13:05Z",
-  "last_seen": "2026-05-15T08:13:05Z",
-  "sessions": [
-    "x7-smoke-25746"
-  ]
-}

40-data/profiles/ca28dcb8ed8b.json

@@ -1,81 +0,0 @@
-{
-  "name_display": "Asha",
-  "name_slug": "asha",
-  "persona_id": "ca28dcb8ed8b",
-  "profile": {
-    "name": "Asha",
-    "age": 35,
-    "dependents": "self+spouse",
-    "income_band": "10L-25L",
-    "existing_cover_inr": null,
-    "primary_goal": "first_buy",
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "desired_sum_insured_inr": null,
-    "health_conditions": [
-      "none"
-    ],
-    "copay_pct": 0,
-    "family_medical_history": [],
-    "smoker": null,
-    "asked": [
-      "copay_pct"
-    ],
-    "free_form_session": false,
-    "shown_policies": [
-      {
-        "policy_slug": "royal-sundaram__multiplier",
-        "insurer": "royal-sundaram",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 1
-      },
-      {
-        "policy_slug": "niva-bupa__reassure-3",
-        "insurer": "niva-bupa",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 2
-      },
-      {
-        "policy_slug": "care__supreme",
-        "insurer": "care",
-        "event_at": "2026-05-16T19:57:41Z",
-        "session_id": "t_1541ede6",
-        "reason": "shown_in_recommendation",
-        "turn_idx": 2
-      }
-    ],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-16T13:12:45Z",
-  "last_seen": "2026-05-16T19:57:41Z",
-  "sessions": [
-    "t_8f24225c",
-    "t_e9ffee10",
-    "t_a40eaba0",
-    "t_15bcbab1",
-    "t_ea2b6e61",
-    "t_f8bf16d3",
-    "t_02f7e949",
-    "t_3fa40ae8",
-    "t_3aa7f39f",
-    "t_5bcb0d4c",
-    "t_8874c358",
-    "t_3c159933",
-    "t_bfb35b97",
-    "t_a5549a35",
-    "t_6602f010",
-    "t_7f5224e7",
-    "t_a220f19b",
-    "t_fd487de1",
-    "t_29a9cb78",
-    "t_1541ede6"
-  ]
-}

40-data/profiles/dd8cd6c71443.json

@@ -1,34 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "dd8cd6c71443",
-  "profile": {
-    "name": "Rohit",
-    "age": 29,
-    "dependents": null,
-    "income_band": "under_5L",
-    "existing_cover_inr": null,
-    "primary_goal": null,
-    "location_tier": null,
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": "under_15k",
-    "health_conditions": [],
-    "asked": [
-      "name",
-      "age",
-      "income_band",
-      "budget"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-15T03:36:28Z",
-  "last_seen": "2026-05-15T03:36:28Z",
-  "sessions": [
-    "ki158_walk_001"
-  ]
-}

40-data/profiles/f31d3896ff05.json

@@ -1,36 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "f31d3896ff05",
-  "profile": {
-    "name": "Rohit",
-    "age": 32,
-    "dependents": "self+spouse+kids",
-    "income_band": null,
-    "existing_cover_inr": 0,
-    "primary_goal": "first_buy",
-    "location_tier": null,
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": "15k_30k",
-    "health_conditions": [],
-    "asked": [
-      "name",
-      "age",
-      "dependents",
-      "primary_goal",
-      "existing_cover",
-      "budget"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-15T01:02:36Z",
-  "last_seen": "2026-05-15T01:02:36Z",
-  "sessions": [
-    "2e4536ac-41ec-4683-aac4-7a069b10f1f6"
-  ]
-}

40-data/profiles/rohit.json

@@ -1,43 +0,0 @@
-{
-  "name_display": "Rohit",
-  "name_slug": "rohit",
-  "persona_id": "93b74ab9ae9f",
-  "profile": {
-    "name": "Rohit",
-    "age": 34,
-    "dependents": "self+spouse+kids",
-    "income_band": "18L",
-    "existing_cover_inr": null,
-    "primary_goal": "first_buy",
-    "location_tier": "metro",
-    "parents_to_insure": null,
-    "parents_age_max": null,
-    "parents_has_ped": null,
-    "budget_band": null,
-    "desired_sum_insured_inr": null,
-    "health_conditions": [],
-    "copay_pct": null,
-    "family_medical_history": [],
-    "smoker": null,
-    "asked": [
-      "name",
-      "age",
-      "dependents",
-      "location_tier",
-      "income_band",
-      "primary_goal"
-    ],
-    "free_form_session": false,
-    "shown_policies": [],
-    "selected_policies": [],
-    "rejected_policies": []
-  },
-  "first_seen": "2026-05-16T06:41:30Z",
-  "last_seen": "2026-05-16T06:42:12Z",
-  "sessions": [
-    "sessA_7d9d11fb",
-    "sessB_595c9c88"
-  ],
-  "recall_pointer": true,
-  "points_to_persona_id": "93b74ab9ae9f"
-}

70-docs/60-decisions/ADR-041-session-profile-lifecycle.md

@@ -1,9 +1,10 @@
 # ADR-041 — Session & profile lifecycle (KI-196)
 
-**Status:** Accepted — 2026-05-15
+**Status:** **SUPERSEDED by [ADR-043](ADR-043-remove-cross-session-recall.md) (2026-05-27).** The two-tier persona_id + name-slug pointer store described below was removed entirely. Sessions are now in-memory only. Kept here for historical record.
+**Originally accepted:** 2026-05-15
 **Owner:** Rohit Saraf
 **Related KIs:** KI-020 (legacy clear-chat), KI-040 (silent name-based recall), KI-062 (persona_id keying), KI-077 (named profile recovery), KI-118 (in-memory-only sessions + cross-session name match), KI-167 (LLM-driven sales brain)
-**Related ADRs:** [ADR-022](ADR-022-conversational-profile-updates.md), [ADR-039](ADR-039-llm-driven-sales-brain.md)
+**Related ADRs:** [ADR-022](ADR-022-conversational-profile-updates.md), [ADR-039](ADR-039-llm-driven-sales-brain.md), [ADR-043](ADR-043-remove-cross-session-recall.md) (supersedes this ADR)
 
 ## Context
 

70-docs/60-decisions/ADR-042-privacy-hardening-and-sticky-retry.md

@@ -1,9 +1,8 @@
 # ADR-042 — Privacy hardening (recall redaction + match-before-merge), sticky-retry schedule, honest canned-failure copy, admin refresh wiring
 
 **Date:** 2026-05-27
-**Status:** Accepted
-**Supersedes:** Extends ADR-041 (`session-profile-lifecycle.md`) on the recall confirm gate; does not replace it.
-**Commits:** `2acdc9e` (v1), `10e6843` (v2 same-turn age contradiction).
+**Status:** **PARTIALLY SUPERSEDED by [ADR-043](ADR-043-remove-cross-session-recall.md) (same day).** The recall-prompt redaction (D3), match-before-merge guard (D4), v3 extended extractors and v4 two-fact gate are obsolete — cross-session recall was removed entirely. The sticky-retry schedule (D1), honest canned-failure copy (D2) and admin refresh wiring (D5) are KEPT and remain in production.
+**Commits:** `2acdc9e` (v1), `10e6843` (v2 same-turn age contradiction), `2be56b4` (v3+v4 extended extractors + two-fact gate).
 
 ## Context
 

70-docs/60-decisions/ADR-043-remove-cross-session-recall.md

@@ -0,0 +1,78 @@
+# ADR-043 — Remove cross-session profile recall entirely
+
+**Date:** 2026-05-27
+**Status:** Accepted
+**Supersedes:** ADR-041 (`session-profile-lifecycle.md`), ADR-042 (`privacy-hardening-and-sticky-retry.md`). The portions of ADR-042 covering sticky-session retry and the admin LLM Chain refresh wiring are KEPT — those concerns are independent of the recall feature and remain live.
+
+## Context
+
+Two-week arc of recall hardening that kept exposing new failure modes:
+
+| Doc / Fix | When | Hardening pass |
+|---|---|---|
+| ADR-041 (session-profile-lifecycle) | 2026-05-15 | Original two-tier name-slug + persona_id JSON store with a staged-confirm Welcome Back gate |
+| KI-196 / Bug #25 | 2026-05-19 | Probe must fire when name lands on turn ≥2, not just turn 1 |
+| Bug #26 (state-recovery) | 2026-05-19 | Container restart mid-conversation → rebuild profile from chat_history |
+| ADR-042 v1 | 2026-05-27 | Redact stored attrs from the Welcome-Back prompt + prior-turn match-before-merge guard |
+| ADR-042 v2 | 2026-05-27 | Same-turn age regex guard (since `_affirm_or_deny` fires before `save_profile_field`) |
+| ADR-042 v3 | 2026-05-27 | Extend extractors to dependents / location_tier / income_band |
+| ADR-042 v4 | 2026-05-27 | Two-fact recall gate in `rehydrate_by_name` — bare name no longer stages |
+
+Each pass was a real bug class. After v4 the live audit still showed seeded-test failures because the slug pointer was being overwritten between tests, exposing the deeper structural truth: **a name-only key cannot safely distinguish two visitors who share the name**, and the workarounds keep accumulating without converging.
+
+Cost/benefit for an insurance-shopping product:
+
+- **Value of recall:** "the bot remembers you next visit." Insurance shopping is rare-purchase (typical user buys once every several years); return sessions are uncommon.
+- **Complexity tax:** ~1500 LOC across `profile_store.py`, `profile_persistence.py`, `profile_rag.py`, ~half of `session_state.py`, the `recall_block` / `restored_block` / `_affirm_or_deny` / `_RECALL_*` constants and the ~70-line prelude in `single_brain.handle_turn`, the `/api/profile/recall-by-name` endpoint + frontend wrapper, `40-data/profiles/<name>.json` × 100+ files on disk, two ADRs, multiple dedicated test files, and audit-time state drift on the live HF Space.
+- **Privacy surface:** the name-slug pointer collides across distinct users; every layer of guard (redaction, match-before-merge, two-fact gate) was added because that collision creates a leak vector. A "minimum data retention" posture sidesteps all of it.
+
+The choice that simplifies all of that in one move: **don't carry anything across sessions.**
+
+## Decision
+
+Remove the cross-session profile recall feature entirely. Sessions are in-memory only.
+
+Concretely:
+
+- **Deleted modules:** `backend/profile_store.py`, `backend/profile_persistence.py`, `backend/profile_rag.py`.
+- **Deleted endpoint:** `POST /api/profile/recall-by-name`. Old clients pinging the path get 404 — the correct degraded response.
+- **Deleted frontend caller:** `postProfileRecallByName` + `RecallByNameResponse` type in `frontend/src/lib/api.ts`.
+- **Deleted symbols (formerly in `backend/session_state.py`):** `rehydrate_by_name`, `apply_pending_recall`, `_AGE_HINT_RE`, `_extract_age_from_text`, `_extract_dependents_from_text`, `_extract_location_tier_from_text`, `_extract_income_band_from_text`, `_parse_user_text_facts`, `_LOCATION_TIER_MAP`, `_RECALL_SUMMARY_FIELDS`, the `pending_profile_recall` / `recall_probe_done` / `recall_match_deferred` fields on `SessionState`.
+- **Deleted symbols (formerly in `backend/single_brain.py`):** `_affirm_or_deny`, `_RECALL_AFFIRM_TOKENS`, `_RECALL_DENY_TOKENS`, `_RECALL_AFFIRM_PHRASES`, `_RECALL_DENY_PHRASES`, `_RECALL_TOKEN_RE`, the entire `recall_block` + `restored_block` prompt sections, the `pending_recall` / `recall_applied` parameters to `_system_instruction`, and the ~70-line recall prelude in `handle_turn`.
+- **Deleted data:** `40-data/profiles/` directory removed from the repo (`git rm -r`) and from the live HF Space's working filesystem on next rebuild.
+- **Deleted tests:** `test_bug2526_recall_and_reconstruct.py`, `test_bug45_chat_profile_persistence.py`, `test_profile_rag_isolation.py`, `test_profile_recall_session_isolation.py`, `test_returning_user_recall_singlebrain.py`. `test_session_no_disk_persistence.py` is KEPT and its docstring updated.
+- **Converted to in-memory:** the `POST /api/profile/select` + `POST /api/profile/reject` shortlist endpoints in `backend/admin.py` now mutate only `SessionState.profile.selected_policies` / `rejected_policies` — no disk write. `brain_tools.mark_recommendation`'s shown-policy tracking is similarly in-memory only.
+- **Converted to live-session view:** `/api/admin/profiles`, `/api/admin/persona-drift`, `/api/admin/recommendation-history` now read from `session_state._sessions` (the in-memory dict of currently live sessions) instead of walking on-disk JSON files.
+
+## What's kept
+
+- **`SessionState.profile`** — still the per-session dataclass, populated by `save_profile_field` and by `POST /api/profile`. Evicted on `_TTL_SECONDS = 60 * 60` idle.
+- **State-recovery from chat_history (Bug #26)** — in-session only. If a container restart blanks `_sessions` but the browser is still on the same tab, the brain rebuilds the profile from the chat history the client re-sends. Never reads disk.
+- **The sticky-session retry policy from ADR-042** (`_gemini_call(is_sticky=True)` with jittered exp backoffs) — kept as-is; it has nothing to do with recall.
+- **The admin LLM Chain refresh wiring from ADR-042** (KI-296) — kept; same independence.
+
+## Consequences
+
+- **Privacy by default.** Closing the tab is a complete forget. No name-keyed cross-session inheritance is possible because no such mechanism exists.
+- **Code volume.** Net deletion ≈ 1,500 LOC plus the 100+ profile JSONs.
+- **Operator view changes shape.** Admin profile / drift / recommendation-history endpoints now show live in-memory sessions only; historical events evict with the session. If long-term analytics are wanted, the right channel is an append-only anonymised `usage_log.jsonl`, not a profile JSON store.
+- **No more "Welcome back, <name>?" UX.** Trade-off accepted — the slug-collision class of bug goes away with it.
+- **State recovery still survives container restarts** for users who stay on the same tab. The common operational concern from Bug #26 is unaffected.
+- **Frontend changes are minimal.** `postProfileRecallByName` is deleted; no callers existed. The Clear-chat / profile-builder UX paths continue to work unchanged.
+
+## Verification
+
+- Compile: every backend module compiles after the deletion.
+- Imports: every backend module imports cleanly under `.venv/bin/python` — no orphan references to removed modules.
+- Grep sweep across `backend/`, `frontend/`, and `tests/` for `profile_store`, `profile_persistence`, `profile_rag`, `rehydrate_by_name`, `apply_pending_recall`, `try_recall_by_name`, `recall_by_name_payload`, `extract_potential_name`, `auto_persist_session`, `pending_profile_recall`, `recall_match_deferred`, `recall_probe_done`, `_RECALL_AFFIRM`, `_RECALL_DENY`, `_affirm_or_deny`, `_extract_age_from_text`, `_extract_dependents_from_text`, `_extract_location_tier_from_text`, `_extract_income_band_from_text`, `_parse_user_text_facts`, `_AGE_HINT_RE`, `_LOCATION_TIER_MAP`, `record_policy_event`, `_LazyProfilesDir`, `_PROFILES_DIR_FOR_DRIFT` — all return zero active code references (only the comment lines in this ADR and the prose pointers in CLAUDE.md / README.md remain).
+- Live audit (deferred to deploy commit) — confirms no Welcome Back text fires regardless of name, the bot proceeds with normal fact-find, and the admin tabs render an empty/live-only view.
+
+## Open follow-ups
+
+None. The deferred recall-feature follow-ups from ADR-042 are dissolved by the removal — there is nothing to disambiguate.
+
+## How this is told in an interview
+
+- Build of trust → forced explicit privacy choices. The product holds user health and family data; "minimum data retention" is a stronger story than "we keep your profile but redact the prompt."
+- Documented the iteration honestly. Five hardening passes on a feature with a high complexity-to-value ratio was the signal to delete, not the signal to ship pass six.
+- Showed the operating discipline of cutting your own code. The change is a 1,500-LOC *deletion*. The simpler architecture is easier to explain, easier to audit, and provably free of the collision-class bug.

CLAUDE.md

@@ -60,7 +60,7 @@ Every LLM role is a `NimChainLLM` candidate pool, NOT a hardcoded single model.
 - **Single LLM call per turn** via `NimChainLLM(FAST_BRAIN_CHAIN)` against the [ADR-040](70-docs/60-decisions/ADR-040-google-gemini-primary.md) three-tier pool (Google Tier 0 → NIM Tier 1 → OpenRouter Tier 2). Google uses **`response_mime_type=application/json`**; NIM uses **`response_format={"type":"json_object"}`**; OpenRouter free-tier candidates (`nvidia/nemotron-3-super-120b-a12b:free`, `qwen/qwen3-next-80b-a3b-instruct:free`) also support `response_format` natively (KI-178 audit). Every candidate enforces structured output server-side — same contract already validated in `backend/translation_check.py`, `backend/faithfulness.py`, and `backend/security.py`. Response shape: `{"reply": "<prose for user>", "captures": {<slot_id>: <raw>}, "slot_driving": "<slot_id|null>", "complete": <bool>}`.
 - **System prompt** carries the 9-slot schema + current profile state. The LLM is free to ask in any order, in any voice, multi-fact in one turn or one slot at a time. No scripted opener, no acknowledger prefix, no `prompt_en` template.
 - **Deterministic post-processor** (`backend/sales_brain_normalizer.py`) takes the LLM's loose `captures` dict and emits a `{canonical_field: validated_value}` map: alias resolution (`location` → `location_tier`), enum normalization (`Bangalore` → `metro`), INR-amount parsing, null/empty drop, type/bounds validation. No LLM calls — pure rules. Override: if LLM sets `complete: true` while any required slot is empty, force `complete: false`.
-- **Profile persistence unchanged.** Captures flow through `session.update_profile_field()` → `backend/profile_store.save_profile()` (disk durability) → `backend/profile_rag.upsert_profile_chunk()` (retrieval-side visibility). KI-102 / KI-107 / KI-112 session-isolation guards remain in force.
+- **Profile persistence (post-ADR-043, 2026-05-27).** Captures flow through `session.update_profile_field()` into the in-memory `SessionState.profile` only. The previous `backend/profile_store.save_profile()` disk write and `backend/profile_rag.upsert_profile_chunk()` Chroma write were **removed entirely** when cross-session recall was retired (ADR-043). Closing the tab discards the profile.
 - **No scripted prompts, no canonical_fallback, no trailer convention.** `backend/needs_finder.py::GRAPH` slot-id data stays as a schema source for the system prompt, but `Question.prompt_en` is dead text — never consulted by the fact-find branch. `_canonical_fallback`, `_normalize_for_slot`, `_pick_opener`, `_NEUTRAL_OPENERS`, `_FAMILY_OPENERS`, `_contains_self_introduction`, the lenient `<FF>` parser ladder, and the `"Got that — {slot}."` prefix logic are deleted.
 - **Outer 25s `asyncio.wait_for` ceiling retained.** On total chain exhaustion (all of Google → NIM → OpenRouter fail in a single turn) the orchestrator returns the graceful error to the user (fail-loud) rather than cascading to a scripted reply. There is no scripted safety net — that is intentional.
 - **DELETED in KI-167:** `backend/fact_find_brain.py` (441 LOC); `_canonical_fallback` + `_pick_opener` branches in `backend/orchestrator.py`; `_ff_failed_attempts` / `_ff_skipped_slots` session fields; every `fact_find_brain::fallback:*` telemetry variant; the lenient `<FF>` / fenced-`json` / bare-JSON-tail parser ladder.
@@ -68,13 +68,13 @@ Every LLM role is a `NimChainLLM` candidate pool, NOT a hardcoded single model.
 - **Natural-conversation escape (KI-045):** intent_change phrases / off-topic questions still exit fact-find by routing through `should_route_to_fact_find` upstream of the brain.
 - **Indic queries** route through Sarvam-M for translation on input + output; the sales brain runs in English on the translated text.
 
-## Session & profile lifecycle (ADR-041, hardened by ADR-042) — KI-196, KI-296
+## Session & profile lifecycle (ADR-043 supersedes ADR-041 + ADR-042)
 
-- **Three identity layers stay distinct.** `session_id` (UUID, in-memory only via `backend/session_state.py`) ≠ `persona_id` (12-char SHA1, keys `40-data/profiles/<persona_id>.json`) ≠ `name_slug` (canonical first-name, Chroma chunk key). New tab = new `session_id`; same-tab refresh = same `session_id` (`sessionStorage`); on-disk profile JSONs are durable user data and are NEVER deleted by frontend actions.
-- **`POST /api/session/clear`** is the canonical "Clear chat" endpoint. Body `{session_id}`; reply `{cleared, new_session_id}`. Wipes the in-memory entry via `clear_session()` and always mints a fresh UUID. The legacy `POST /api/session/reset` (KI-020) is left in place for backwards compatibility but the frontend Clear-chat button calls `/api/session/clear`.
-- **Confirmation-gated profile recall (privacy-hardened 2026-05-27, ADR-042).** When a fresh session captures a `name` that matches an on-disk profile, the brain stages the match into `session.pending_profile_recall` and emits a **redacted** welcome-back ask — *"Welcome back — have we spoken before? If yes, please share your age so I can pull up the right profile. If not, no problem — just say so and we'll start fresh."* — NEVER disclosing the staged attrs (age / dependents / location / goal). The user's NEXT message hits the affirm/deny gate at the top of `handle_turn`. **Match-before-merge guard** in `apply_pending_recall(session, *, confirmed, user_text)` discards the staged recall when any decision-critical staged field contradicts either a prior-turn live capture *or* a same-turn age parsed from `user_text` (best-effort regex `_extract_age_from_text`). Two-tier scheme on disk: `<persona_id>.json` is canonical, `<name_slug>.json` is the recall pointer rewritten by every save.
-- **Sticky-session retry policy (ADR-042).** `_gemini_call` accepts `is_sticky` (read once from `session.single_brain_sticky` in `handle_turn`). Non-sticky: 1 retry @ 1.5 s (fast-fail to nim_fallback on cold-start). Sticky: 2 retries with jittered exp backoffs (1.5 s → 3 s, ±25 %). The user-facing canned reply on exhausted retries is now *"My model service had a brief blip on that turn — please send the same message again, it should go through now."* (not "could you say that again?").
-- **Profile completeness gates on `Profile.asked`.** Default `dependents="self"` pre-fill in the builder form no longer registers as "done"; `profile_completeness_view` + `POST /api/profile` mask any field not in the `asked` list before scoring. The "Your profile X% done" badge now starts at 0% for a brand-new session and only ticks up on explicit captures.
+- **Sessions are in-memory only.** ADR-043 (2026-05-27) removed the cross-session recall layer entirely. `SessionState` lives in process memory in `session_state._sessions`; idle entries are evicted after `_TTL_SECONDS = 60 * 60`. There is no on-disk profile store, no name-slug pointer, no persona_id JSON, no profile_rag Chroma chunk, no Welcome-Back prompt, no `pending_profile_recall`, no `apply_pending_recall`, no `try_recall_by_name`, no `_extract_*_from_text` extractors. Closing the tab or hitting *Clear chat* discards the profile permanently — that's the privacy contract.
+- **`POST /api/session/clear`** is the canonical "Clear chat" endpoint. Body `{session_id}`; reply `{cleared, new_session_id}`. Wipes the in-memory entry via `clear_session()` and always mints a fresh UUID. The legacy `POST /api/session/reset` (KI-020) is left in place for backwards compatibility.
+- **State-recovery from chat_history (Bug #26, in-session only).** If a container restart / >1 h idle blanked the server-side session BUT the browser is still on the same tab carrying the chat history, the brain enters **STATE-RECOVERY MODE** and silently re-captures the already-stated facts from history via `save_profile_field`. This is purely in-session resilience — it never reads disk, never crosses sessions.
+- **Sticky-session retry policy (kept from ADR-042).** `_gemini_call` accepts `is_sticky` (read once from `session.single_brain_sticky` in `handle_turn`). Non-sticky: 1 retry @ 1.5 s (fast-fail to nim_fallback on cold-start). Sticky: 2 retries with jittered exp backoffs (1.5 s → 3 s, ±25 %). The user-facing canned reply on exhausted retries: *"My model service had a brief blip on that turn — please send the same message again, it should go through now."*
+- **Profile completeness gates on `Profile.asked`.** Default `dependents="self"` pre-fill in the builder form no longer registers as "done"; `profile_completeness_view` + `POST /api/profile` mask any field not in the `asked` list before scoring. The "Your profile X% done" badge starts at 0% for a brand-new session and only ticks up on explicit captures.
 
 ## Refusal precision (KI-046)
 

README.md

@@ -125,13 +125,8 @@ to deciding with confidence.
 
 ```mermaid
 flowchart TD
-    S["🌐 You open the app — web or mobile, nothing to install"] --> R{"Used it before?"}
-    R -->|"Returning"| WB["👋 "Welcome back, <name>?" — your earlier profile is offered back"]
-    R -->|"First time"| TELL
-    WB -->|"yes, that's me"| KNOWN["Picks up with your saved profile — no re-typing"]
-    WB -->|"no / not me"| TELL
-    KNOWN --> REC
-    TELL["🗣️ Tell it about you — a short chat, typed OR spoken, English / Hindi-Hinglish<br/>age · family · budget · health · what you care about"] --> ASK["❓ It asks just 2–3 clarifying questions<br/>(a real conversation, never a long form)"]
+    S["🌐 You open the app — web or mobile, nothing to install"] --> TELL["🗣️ Tell it about you — a short chat, typed OR spoken, English / Hindi-Hinglish<br/>age · family · budget · health · what you care about"]
+    TELL --> ASK["❓ It asks just 2–3 clarifying questions<br/>(a real conversation, never a long form)"]
     ASK --> REC["🎯 A personalised shortlist — plans ranked for YOUR fit, each with the reason it fits"]
     REC --> WHY["🔍 Open any plan: every fact is backed by the exact clause in the real policy PDF<br/>an honest &quot;not stated in the document&quot; instead of a guess"]
     WHY --> EXPLORE{"Want to dig deeper?"}
@@ -148,16 +143,14 @@ flowchart TD
     VOICE -.-> QA
 ```
 
-**Summary.** A first-time user opens the app and ends the
-session having decided on a plan with confidence — and how the system loops
-through compare / browse / Q&A / upload along the way. No backend in this
-view; just the human path.
+**Summary.** A user opens the app and ends the session having decided on
+a plan with confidence — and how the system loops through compare /
+browse / Q&A / upload along the way. No backend in this view; just the
+human path. Every session starts fresh — there is no cross-session
+memory; closing the tab forgets you (privacy-by-design, see ADR-043).
 
 **How it flows:**
 
-- **Returning-user check up front.** If the app recognises your name from
-  before, it offers to restore your saved profile (so you never re-type);
-  *no* takes you down the same path as a first-time user.
 - **Conversational fact-find.** A short typed-or-spoken back-and-forth
   (English or Hindi-Hinglish) captures age, family, budget, health and
   what you care about — instead of a long form.
@@ -204,7 +197,7 @@ flowchart LR
         API["HTTP endpoints + orchestration<br/>backend/main.py"]
         BRAIN["🧠 LLM Brain<br/>Google Gemini + function-calling tools<br/>(NIM fallback chain on failure)"]
         SCORE["🎯 Scoring + Pricing<br/>scorecard.py · premium_calculator.py"]
-        PROF["👤 Profile & Persistence<br/>session_state · profile_store"]
+        PROF["👤 Profile (in-memory only)<br/>session_state.SessionState · 1h idle TTL"]
     end
     subgraph DATA["📚 Data layer"]
         VEC["Vector DB (Chroma) — policy chunks<br/>+ per-session quarantine (uploads)"]
@@ -233,7 +226,7 @@ flowchart LR
 
 - **1. Frontend (browser · Next.js).** Renders chat, marketplace, compare, and the profile builder. Sends typed text and audio over HTTP, plays the synthesised reply.
 - **2. Voice.** `Sarvam STT (in)` turns spoken audio into a text turn; `Sarvam TTS (out)` turns the reply text back into spoken audio.
-- **3. Backend (FastAPI).** Four sub-blocks — **3a** HTTP endpoints + orchestration (`backend/main.py`); **3b** LLM Brain (Gemini + function-calling tools; NIM fallback on failure); **3c** Scoring + Pricing (`scorecard.py` + `premium_calculator.py`); **3d** Profile & Persistence (`session_state` + `profile_store`).
+- **3. Backend (FastAPI).** Four sub-blocks — **3a** HTTP endpoints + orchestration (`backend/main.py`); **3b** LLM Brain (Gemini + function-calling tools; NIM fallback on failure); **3c** Scoring + Pricing (`scorecard.py` + `premium_calculator.py`); **3d** Profile (in-memory only — `session_state.SessionState`, no disk).
 - **4. Data layer.** Two stores — the Chroma **vector DB** (shared policy chunks + per-session quarantine for uploads) and curated **JSON facts** at `40-data/policy_facts/*.json`. The brain, scoring, and pricing all read from these.
 
 **Diagram legend (used throughout §2):**
@@ -283,10 +276,9 @@ flowchart TB
             SC1["grade_per_profile<br/>scorecard.py"]
             SC2["estimate_premium<br/>premium_calculator.py"]
         end
-        subgraph BE_PROF["3d. Profile & Persistence"]
-            P1["update_session_profile"]
-            P2["persist_to_disk<br/>end of turn"]
-            P3["recall_by_name<br/>returning user"]
+        subgraph BE_PROF["3d. Profile (in-memory)"]
+            P1["update_session_profile<br/>session_state.SessionState"]
+            P2["evict_on_idle<br/>1h TTL · no disk"]
         end
     end
 
@@ -294,7 +286,6 @@ flowchart TB
         direction TB
         D1["vector_search<br/>Chroma · BGE-small"]
         D2["fact_lookup<br/>40-data/policy_facts/*.json"]
-        D3["read_user_profile<br/>40-data/profiles/&lt;name&gt;.json"]
     end
 
     %% forward edges (input / down the pipeline)
@@ -310,19 +301,17 @@ flowchart TB
     B2 --> P1
     B3 --> D1
     B4 --> D2
-    P3 --> D3
     A2 --> SC1
     A2 --> SC2
     SC1 -->|"reads"| D2
     SC2 -->|"reads"| D2
     SC1 -->|"reads"| P1
     SC2 -->|"reads"| P1
-    P1 -.->|"end of turn"| P2
+    P1 -.->|"idle 1h"| P2
 
     %% return edges (output / back to caller)
     D1 -.->|"top-k chunks"| B3
     D2 -.->|"per-policy facts"| B4
-    D3 -.->|"saved profile"| P3
     SC1 -.->|"grade"| A2
     SC2 -.->|"premium range"| A2
     B1 -.->|"reply + citations"| A2
@@ -331,8 +320,8 @@ flowchart TB
     V2 -.->|"audio"| F2
 
     %% blue solid = forward · orange dashed = return
-    linkStyle 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18 stroke:#1565c0,stroke-width:2px
-    linkStyle 19,20,21,22,23,24,25,26,27 stroke:#e65100,stroke-width:2px,stroke-dasharray:6 3
+    linkStyle 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17 stroke:#1565c0,stroke-width:2px
+    linkStyle 18,19,20,21,22,23,24,25 stroke:#e65100,stroke-width:2px,stroke-dasharray:6 3
 ```
 
 **Legend.** Blue solid = forward flow (input / call down the pipeline). Orange dashed = return flow (result / reply back up).
@@ -346,8 +335,8 @@ flowchart TB
 - **3a. HTTP + orchestration.** `route_request` maps the URL to a handler; `orchestrate_turn` is the per-turn supervisor — it owns the request lifecycle and ties brain + scoring + voice + persistence together.
 - **3b. LLM Brain.** One `handle_turn` per turn calls Gemini, which chooses which of `fact_find` / `retrieve` / `lookup_facts` / `recommend` to run as tools. The brain may only state what its tools returned.
 - **3c. Scoring + Pricing.** `grade_per_profile` and `estimate_premium` read curated facts **and** the live profile, compute on every request (never stored), and hand back to `orchestrate_turn`.
-- **3d. Profile & Persistence.** `update_session_profile` reflects each `fact_find` write into the live session; `persist_to_disk` runs end-of-turn so the next visit can call `recall_by_name`.
-- **4. Data layer.** Three reads — `vector_search` for free-form Q&A, `fact_lookup` for decision-critical numbers with verbatim quotes, and `read_user_profile` for returning-user recall. The data layer does no writes during a request; those happen offline (vectors) or end-of-turn (profile).
+- **3d. Profile (in-memory).** `update_session_profile` reflects each `fact_find` write into the live `SessionState.profile`. State lives in process memory only; an idle session is evicted after 1 h. There is no disk persistence and no cross-session recall (see ADR-043, 2026-05-27).
+- **4. Data layer.** Two reads — `vector_search` for free-form Q&A, and `fact_lookup` for decision-critical numbers with verbatim quotes. The data layer does no writes during a request — those happen offline only (vector ingest, curated-facts edits).
 
 ### 2.4 LLM brain + fail-loud fallback chain
 
@@ -462,67 +451,60 @@ over the bot (**barge-in**) pauses that audio **and** aborts the in-flight
 push-to-talk; the live interim transcript accumulates the full utterance
 while you speak.
 
-### 2.6 Profile, personalisation & returning-user recall
+### 2.6 Profile & personalisation (in-memory only)
 
 ```mermaid
 flowchart TB
-    A["user answers (chat or profile builder)"] --> SPF["save_profile_field → session_state.profile"]
-    SPF --> ENDT["end of handle_turn"]
-    ENDT --> AP["auto_persist_session()<br/>(no-op if no name; errors swallowed)"]
-    AP --> DISK["profile_store: 40-data/profiles/&lt;name&gt;.json"]
-    AP --> EMB["profile_rag: session-scoped profile chunk"]
-    RV["return visit — user states a name"] --> EX["extract name"]
-    EX --> TR["try_recall_by_name (first-name slug fallback)"]
-    TR --> DISK
-    TR --> STAGE["session.pending_profile_recall (STAGED, never auto-merged)"]
-    STAGE --> ASK["bot: 'Welcome back — have we spoken before? Please share your age'<br/>(stored attrs NEVER disclosed to an unconfirmed identity)"]
-    ASK -->|"yes + matching age"| MERGE["apply_pending_recall (match-before-merge) → merge stored slots"]
-    ASK -->|"yes + mismatching age"| DROP["same-turn age contradiction → discard staged · fresh fact-find"]
-    ASK -->|"no"| FRESH["discard · continue as new user"]
-    SPF --> FIT["scorecard fit + grade"]
-    SPF --> PREM["illustrative premium"]
-    note1["evicted/blank session + carried chat_history →<br/>STATE-RECOVERY: rebuild profile from history,<br/>never re-ask the name"] -.-> ENDT
+    A["user answers (chat or profile builder)"] --> SPF["save_profile_field → SessionState.profile<br/>(in-memory dict only)"]
+    SPF --> FIT["scorecard fit + grade<br/>(reads live profile)"]
+    SPF --> PREM["illustrative premium<br/>(reads live profile)"]
+    SPF --> TURN["next chat turn<br/>(brain sees full live profile)"]
+    SPF -.->|"1h idle"| EVICT["session evicted from memory<br/>profile gone forever"]
+    SPF -.->|"close tab"| EVICT
+    RECOV["server restart / 1h idle WHILE tab still open<br/>+ chat_history carried by browser"] -.-> SR["STATE-RECOVERY MODE<br/>brain rebuilds profile from chat_history<br/>(in-session only · never reads disk)"]
+    SR --> SPF
 ```
 
-**Summary.** How the system captures a profile during a
-conversation, persists it for the user's next visit, recalls it *safely* on
-return, and recovers when the server forgot it.
+**Summary.** The profile is captured into a per-session in-memory dict
+(`SessionState.profile`), feeds scoring + pricing + the next turn's
+brain prompt, and is discarded the moment the session evicts (1 h idle
+or "Clear chat"). There is no on-disk persistence and no cross-session
+recall. The in-session **STATE-RECOVERY** path covers container
+restarts by rebuilding the profile from the chat history the browser
+still carries — it never touches disk.
 
 **How it flows:**
 
-- **Capture.** Every answer (chat or profile-builder) is persisted via
-  `save_profile_field` into the live `session_state.profile`.
-- **End-of-turn persist.** `auto_persist_session` writes a
-  `<name>.json` to disk **and** embeds the profile as a session-scoped
-  chunk — so a returning user can be recognised, and "given my situation"
-  references can be grounded.
-- **Privacy-safe recall (hardened 2026-05-27).** On a return visit the
-  captured name is matched against the stored profile; a match is
-  **staged** on `pending_profile_recall` and the bot asks *"Welcome
-  back — have we spoken before? Please share your age."* The prompt
-  **never discloses** the staged attributes (age / dependents /
-  location / goal) — a stranger sharing the name slug can't learn the
-  prior visitor's profile from the prompt alone. Only an explicit *yes*
-  with a **matching age** merges stored slots (`apply_pending_recall`
-  runs a *match-before-merge* contradiction guard against both prior
-  live-session captures *and* the just-said `user_text`); a *no* or a
-  mismatching age discards the stage and the user continues fresh.
-- **State recovery.** If the server's in-memory session was evicted /
-  restarted but the browser still carries `chat_history`, the brain
-  enters **STATE-RECOVERY MODE** — silently re-captures the profile from
-  the conversation history instead of asking the user's name again.
+- **Capture.** Every answer (chat or profile-builder form) is written via
+  `save_profile_field` (or the `POST /api/profile` endpoint) into the
+  live `SessionState.profile`. This is a regular Python dataclass field
+  on the in-memory session object.
 - **Drives scoring + pricing.** The same profile feeds the scorecard
-  fit-and-grade and the live premium estimate.
-
-**More on profile & personalisation.** Your answers build a session
-profile (`backend/session_state.py`, `profile_store.py`,
-`profile_persistence.py`). The profile is also embedded as a
-*session-scoped* chunk (`backend/profile_rag.py`) so the brain can ground
-"given my situation" references, with strict per-session isolation. The
-*same* profile drives both recommendation fit (scorecard) and the
-illustrative premium estimate (`backend/premium_calculator.py`,
-`sum_insured.py`) — see §3.2 and §3.3 for what each function actually
-computes.
+  fit-and-grade (§3.2) and the live premium estimate (§3.3) on every
+  request — both reads, never persisted.
+- **Evicted on idle / close.** A session is evicted from the
+  `_sessions` dict after 1 h of inactivity (`_TTL_SECONDS`). Hitting
+  *Clear chat* (`POST /api/session/clear`) evicts immediately. Closing
+  the tab disconnects the browser — the server-side session ages out on
+  the same TTL.
+- **State recovery (in-session only).** If the server restarted or the
+  session evicted *while the browser still has the chat open*, the
+  client re-sends its `chat_history` with the next turn. The brain
+  enters **STATE-RECOVERY MODE** and silently re-captures the facts
+  already stated in history — without ever asking the user's name
+  again. This is **not** cross-session; it only resolves the case
+  where the user is still in the same conversation.
+
+**Why no cross-session recall (ADR-043, 2026-05-27).** An earlier
+design persisted profiles to `40-data/profiles/<name>.json` and offered
+a "Welcome back, <name>?" prompt on return. The name-only slug key
+collided across distinct users (every "Rohit" wrote to the same file),
+which required four sequential hardening passes — prompt redaction,
+match-before-merge guards, same-turn fact extractors, a two-fact gate —
+to keep contained. The cost/benefit for an insurance-shopping app
+(rare-purchase, return sessions uncommon) didn't justify the surface.
+The simpler "session is in-memory only" model matches the privacy story
+the product wants to tell.
 
 ### 2.7 Data architecture — where the JSON lives, where the vectors live
 
@@ -544,9 +526,9 @@ computes.
 - **`40-data/reviews/`** — sourced insurer reviews (claims stories, regulator notes).
 - **`40-data/premiums/`** — illustrative public rate-card combinations consumed by the multivariate premium estimator (§3.3).
 - **`40-data/insurer_network.json`** — hospital-network counts per insurer.
-- **`40-data/profiles/<name>.json`** — saved user profiles for returning-user recall. Per-named-user, server-side, never indexed into the shared corpus.
+_Pre-ADR-043 there was also a `40-data/profiles/<name>.json` directory of saved user profiles for cross-session recall. That mechanism was removed (see §2.6 — sessions are now in-memory only)._
 
-All four sit in the **code repo** (under `40-data/`) because they're small, human-reviewed, and decision-critical — safe to version alongside the code.
+All three remaining stores sit in the **code repo** (under `40-data/`) because they're small, human-reviewed, and decision-critical — safe to version alongside the code.
 
 #### 2.7.3 Where each piece physically lives
 
@@ -824,39 +806,38 @@ sequenceDiagram
 - **No LLM in the path.** A plain file read of `40-data/policy_facts/<id>.json`. The brain quotes the value (and the `source_quote`) verbatim.
 - **Used by more than the brain.** `scorecard.py` and `premium_calculator.py` also read these JSON files directly — see §2.3 (the brain's edge is not the only edge into the JSON).
 
-### 3.6 Returning-user recall
+### 3.6 In-session state recovery (server restart resilience)
 
 ```mermaid
 sequenceDiagram
     autonumber
     participant U as User
+    participant Br as Browser (carries chat_history)
     participant B as 3b. LLM Brain
-    participant T as save_profile_field
-    participant S as 3d. session_state
-    participant D as 4. saved profile JSON file
-    U->>B: "Hi, I'm Neha"
-    B->>T: save_profile_field("name", "Neha")
-    T->>S: write name
-    S->>D: try_recall_by_name("Neha")
-    D-->>S: stored profile (staged on pending_profile_recall)
-    S-->>B: "Welcome back — are you the same Neha?"
-    U->>B: "yes" / "no"
-    alt yes
-        B->>S: apply_pending_recall → merge stored slots
-    else no
-        B->>S: discard stage · continue as fresh user
-    end
+    participant S as 3d. SessionState (in-memory)
+    U->>Br: "what about premium?"
+    Br->>B: chat turn + chat_history[N msgs]
+    B->>S: get_session(session_id)
+    Note over S: session was evicted<br/>(1h idle / restart)<br/>profile = BLANK
+    B->>B: STATE-RECOVERY MODE<br/>chat_history has prior facts
+    B->>S: save_profile_field for each fact in history
+    B-->>Br: reply that picks up where it left off<br/>(never re-asks the name)
 ```
 
-**Summary.** When a returning user gives a name that matches a stored profile, the match is **staged**, never auto-merged — the bot asks "are you the same Neha?" and only an explicit *yes* restores the saved slots. This prevents a name collision from leaking a stranger's profile.
+**Summary.** Sessions are in-memory only (`_TTL_SECONDS = 1h`), so a
+container restart or long idle wipes the server-side profile. When the
+browser still carries the conversation, the brain silently rebuilds the
+profile from the chat history instead of starting over. No disk read,
+no cross-session memory — purely a same-conversation resilience path.
 
 **How it flows:**
 
-- **Capture name.** Same path as any other fact (§3.1).
-- **Lookup.** `try_recall_by_name` checks `40-data/profiles/<slug>.json` with a first-name slug fallback.
-- **Stage, don't merge.** A match goes on `session.pending_profile_recall` — *not* into `session.profile`.
-- **Confirm gate.** The bot asks the user to confirm. *yes* → merge stored slots into the live profile. *no* → discard the stage and continue as a fresh user.
-- **Bonus: state recovery.** If the server's in-memory session was evicted but the browser still carries `chat_history`, the brain enters **STATE-RECOVERY MODE** and silently rebuilds the profile from history rather than asking for the name again.
+- **Detect.** `get_session()` returns a blank `SessionState`, but `chat_history` arrives with ≥2 messages including a prior user turn → state was lost, not "fresh user".
+- **Re-capture from history.** A high-priority **STATE-RECOVERY MODE** prompt block tells the LLM: do not say you lost anything, do not re-ask the name, instead call `save_profile_field` for every fact present in the conversation so far, then continue.
+- **Resume.** From the LLM's point of view the next reply is just the next turn in an ongoing chat — the user never perceives the eviction.
+
+(There is no cross-session recall — see §2.6 and ADR-043 for why that
+was removed.)
 
 ### 3.7 What is stored vs what is live-only
 
@@ -864,7 +845,7 @@ sequenceDiagram
 |---|---|---|
 | Policy PDFs + vector chunks | `rag/corpus/` + Chroma store (HF dataset → pulled at build) | Built once, offline; read every request |
 | Curated policy facts (per policy) | `40-data/policy_facts/*.json` (code repo) | Small, human-reviewed, versioned with code |
-| Saved user profile (by name) | `40-data/profiles/<name>.json` (server-side, per-named-user) | So a returning user can be recognised |
+| User profile (current session) | **In-memory only — `SessionState.profile` (1 h idle TTL, no disk)** | Closing the tab / clearing chat forgets the profile by design (ADR-043) |
 | Per-policy **grade / scorecard** | **Not stored — live per request** | Two users get two grades for the same policy (profile-aware) |
 | **Premium range** for a policy | **Not stored — live per request** | Same reason as the grade |
 | Uploaded PDFs | Per-session Chroma quarantine, **24 h TTL** | Isolated to the uploader, never the shared corpus |
@@ -1005,8 +986,7 @@ these:
 │   │   retrieval_filters.py
 │   ├── premium_calculator.py profile → illustrative premium
 │   │   sum_insured.py
-│   ├── session_state.py /    per-session profile + persistence
-│   │   profile_store.py / profile_persistence.py / profile_rag.py
+│   ├── session_state.py      per-session profile (in-memory only, ADR-043)
 │   ├── voice_format.py       TTS pre-processing (money/Indic normalisation)
 │   ├── admin.py              /api/admin/* (health, telemetry)
 │   └── providers/            thin clients: google_gemini, nvidia_nim, sarvam_*,

backend/admin.py

@@ -280,7 +280,7 @@ async def admin_usage(
 
 
 # ---------------------------------------------------------------------------
-# /api/admin/profiles — list every named profile + summary
+# /api/admin/profiles — live-session snapshot (ADR-043, 2026-05-27)
 # ---------------------------------------------------------------------------
 
 @router.get("/api/admin/profiles")
@@ -288,37 +288,49 @@ async def admin_profiles(
     request: Request,
     x_admin_password: Optional[str] = Header(default=None, alias="X-Admin-Password"),
 ):
-    """List every named profile in the JSON store + lightweight summary.
-
-    Returned shape:
-      {
-        "profiles": [ {name_display, name_slug, first_seen, last_seen,
-                       session_count, profile_complete_fields}, ... ],
-        "total": N,
-        "snapshot_ts": "2026-05-14T..."
-      }
+    """List every CURRENTLY LIVE in-memory session + lightweight summary.
+
+    Pre-ADR-043 this read from `40-data/profiles/<name>.json` and exposed a
+    cross-session audit of every named visitor. The on-disk store is gone;
+    operators get the live picture instead — every session that is in
+    `session_state._sessions` right now (i.e. hasn't been idle-evicted).
+    Returned shape stays close to the prior schema so the existing admin
+    UI keeps rendering without changes.
     """
     _check_admin(request, x_admin_password)
 
-    from backend import profile_store
-    profiles = profile_store.list_profiles()
-    return {
-        "profiles": profiles,
-        "total": len(profiles),
-        "snapshot_ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-    }
+    from backend import session_state as _ss
+    now_iso = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    rows = []
+    with _ss._lock:
+        for sid, s in list(_ss._sessions.items()):
+            p = s.profile
+            name = (getattr(p, "name", None) or "").strip()
+            filled = sum(
+                1 for fld in (
+                    "name", "age", "dependents", "income_band",
+                    "location_tier", "primary_goal", "health_conditions",
+                )
+                if getattr(p, fld, None) not in (None, "", [])
+            )
+            rows.append({
+                "name_display": name or "(anonymous)",
+                "name_slug": name.lower().replace(" ", "-") if name else "",
+                "session_id": sid,
+                "last_seen": datetime.fromtimestamp(s.last_touched, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "session_count": 1,
+                "profile_complete_fields": filled,
+            })
+    return {"profiles": rows, "total": len(rows), "snapshot_ts": now_iso}
 
 
 # ---------------------------------------------------------------------------
-# KI-063 (2026-05-15) — user-facing profile-event endpoints.
-#
-# These are NOT admin-gated — they're invoked by the frontend when a logged-
-# in user (one with a stored profile.name) clicks the select/reject buttons
-# on a policy card. Both look up the session, validate that the session has
-# a named profile, then append the event through `profile_store.record_policy_event`.
+# /api/profile/select + /api/profile/reject — IN-MEMORY shortlist tracker
+# (ADR-043, 2026-05-27)
 #
-# Anonymous sessions (no profile.name) get 400 — there's no key to persist
-# against. The frontend should hide the buttons in that case.
+# Pre-ADR-043 these appended events to the named-profile JSON file. They
+# now mutate only the live SessionState. Closes the tab ⇒ shortlist gone.
+# The frontend's shortlist UI continues to work within one session.
 # ---------------------------------------------------------------------------
 
 
@@ -329,46 +341,51 @@ class _PolicyEventBody(BaseModel):
     reason: Optional[str] = None
 
 
+_EVENT_TYPE_TO_FIELD = {
+    "selected": "selected_policies",
+    "rejected": "rejected_policies",
+}
+
+
 def _do_record_policy_event(body: _PolicyEventBody, event_type: str) -> dict:
-    """Shared handler for /api/profile/select + /api/profile/reject."""
+    """Append a shortlist event to the LIVE in-memory profile."""
     if not body.session_id or not body.policy_slug or not body.insurer:
         raise HTTPException(
             status_code=400,
             detail="session_id, policy_slug, and insurer are required",
         )
+    if event_type not in _EVENT_TYPE_TO_FIELD:
+        raise HTTPException(status_code=400, detail="invalid event_type")
     from backend.session_state import get_session
-    from backend.profile_store import record_policy_event
 
     session = get_session(body.session_id)
-    if not session.profile.name:
-        raise HTTPException(
-            status_code=400,
-            detail="No named profile on this session — cannot persist event.",
-        )
-    ok = record_policy_event(
-        persona_id_or_name=session.profile.name,
-        profile=session.profile,
-        event_type=event_type,  # type: ignore[arg-type]
-        policy_slug=body.policy_slug,
-        insurer=body.insurer,
-        session_id=body.session_id,
-        reason=body.reason,
+    p = session.profile
+    field_name = _EVENT_TYPE_TO_FIELD[event_type]
+    entries: list[dict] = list(getattr(p, field_name, None) or [])
+    # Dedup on policy_slug — bump timestamp + reason on repeat clicks.
+    dedup_idx = next(
+        (i for i, e in enumerate(entries)
+         if (e or {}).get("policy_slug") == body.policy_slug),
+        None,
     )
-    if not ok:
-        raise HTTPException(status_code=500, detail="profile save failed")
-    # Also persist via the session flush so an in-memory consumer (e.g. the
-    # welcome-back greeter) reads the same state without a full disk reload.
-    session._flush()
-    field_name = {
-        "shown": "shown_policies",
-        "selected": "selected_policies",
-        "rejected": "rejected_policies",
-    }[event_type]
+    now_iso = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    payload = {
+        "policy_slug": body.policy_slug,
+        "insurer": body.insurer,
+        "event_at": now_iso,
+        "session_id": body.session_id,
+        "reason": body.reason or ("user_clicked_select" if event_type == "selected" else "user_clicked_reject"),
+    }
+    if dedup_idx is not None:
+        entries[dedup_idx] = {**entries[dedup_idx], **payload}
+    else:
+        entries.append(payload)
+    setattr(p, field_name, entries)
     return {
         "ok": True,
         "event_type": event_type,
         "policy_slug": body.policy_slug,
-        "count": len(getattr(session.profile, field_name, []) or []),
+        "count": len(entries),
     }
 
 
@@ -1011,37 +1028,32 @@ async def admin_persona_drift(
     request: Request,
     x_admin_password: Optional[str] = Header(default=None, alias="X-Admin-Password"),
 ):
-    """Return slot-capture completeness for the last 20 personas, newest first.
+    """Slot-capture completeness for LIVE in-memory sessions (newest first).
 
-    Each row: { persona_id, name_display, last_seen, captured_slots,
-                completeness_pct, missing_slots }
-    The frontend highlights any row with completeness_pct < 50.
+    Pre-ADR-043 this walked `40-data/profiles/*.json` and showed every
+    named visitor's slot-capture progress. The on-disk store is gone;
+    operators now see the live picture only.
     """
     _check_admin(request, x_admin_password)
-    if not _PROFILES_DIR_FOR_DRIFT.exists():
-        return {"personas": [], "total": 0,
-                "snapshot_ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")}
+    from backend import session_state as _ss
 
     rows: list[dict] = []
-    for p in _PROFILES_DIR_FOR_DRIFT.glob("*.json"):
-        try:
-            raw = json.loads(p.read_text())
-        except Exception:
-            continue
-        profile = raw.get("profile") or {}
-        asked = profile.get("asked") or []
-        captured = [s for s in _PERSONA_DRIFT_SLOTS if _slot_captured(profile, s, asked)]
-        missing = [s for s in _PERSONA_DRIFT_SLOTS if s not in captured]
-        rows.append({
-            "persona_id":       raw.get("persona_id") or raw.get("name_slug") or p.stem,
-            "name_display":     raw.get("name_display") or "—",
-            "last_seen":        raw.get("last_seen"),
-            "captured_slots":   captured,
-            "missing_slots":    missing,
-            "completeness_pct": round(100.0 * len(captured) / len(_PERSONA_DRIFT_SLOTS), 1),
-            "session_count":    len(raw.get("sessions") or []),
-        })
-    # Newest first by last_seen (None sorts last)
+    with _ss._lock:
+        for sid, s in list(_ss._sessions.items()):
+            p = s.profile
+            profile_dict = {fld: getattr(p, fld, None) for fld in _PERSONA_DRIFT_SLOTS}
+            asked = list(getattr(p, "asked", None) or [])
+            captured = [s_ for s_ in _PERSONA_DRIFT_SLOTS if _slot_captured(profile_dict, s_, asked)]
+            missing = [s_ for s_ in _PERSONA_DRIFT_SLOTS if s_ not in captured]
+            rows.append({
+                "persona_id":       sid,
+                "name_display":     (getattr(p, "name", None) or "—"),
+                "last_seen":        datetime.fromtimestamp(s.last_touched, tz=timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+                "captured_slots":   captured,
+                "missing_slots":    missing,
+                "completeness_pct": round(100.0 * len(captured) / len(_PERSONA_DRIFT_SLOTS), 1),
+                "session_count":    1,
+            })
     rows.sort(key=lambda r: (r["last_seen"] or ""), reverse=True)
     rows = rows[:20]
     return {
@@ -1052,36 +1064,6 @@ async def admin_persona_drift(
     }
 
 
-# Cached path resolver — re-uses profile_store's _PROFILES_DIR but we import
-# lazily to avoid a circular import at module top.
-def _resolve_profiles_dir() -> Path:
-    from backend import profile_store
-    return profile_store._PROFILES_DIR
-
-
-# Lazy-evaluated singleton — instantiate on first call. We can't reference
-# profile_store at module top because admin.py imports llm_health which
-# may not yet have its config wired during tests.
-class _LazyProfilesDir:
-    def __init__(self) -> None:
-        self._p: Optional[Path] = None
-    def __getattr__(self, name: str):
-        if self._p is None:
-            self._p = _resolve_profiles_dir()
-        return getattr(self._p, name)
-    def exists(self) -> bool:
-        if self._p is None:
-            self._p = _resolve_profiles_dir()
-        return self._p.exists()
-    def glob(self, pat: str):
-        if self._p is None:
-            self._p = _resolve_profiles_dir()
-        return self._p.glob(pat)
-
-
-_PROFILES_DIR_FOR_DRIFT = _LazyProfilesDir()
-
-
 # ---------------------------------------------------------------------------
 # A5 — Audit fix #5: /api/admin/recommendation-history — last 10 policy
 # recommendation events across all profiles, newest first.
@@ -1092,46 +1074,35 @@ async def admin_recommendation_history(
     request: Request,
     x_admin_password: Optional[str] = Header(default=None, alias="X-Admin-Password"),
 ):
-    """Return the last 10 policy-event entries across every profile,
-    newest first.
-
-    Each row: { persona_id, name_display, event_type, policy_slug, insurer,
-                event_at, session_id, outcome }
-    outcome: 'selected' / 'rejected' / 'shown' (passthrough from event_type;
-             callers may map 'shown' → 'abandoned' if no follow-up exists,
-             but we leave the raw label so the operator can decide).
+    """Last 10 policy-event entries across LIVE in-memory sessions.
+
+    Pre-ADR-043 this walked `40-data/profiles/*.json` and surfaced every
+    historical shown/selected/rejected event the bot had ever logged. The
+    on-disk store is gone; this now reflects the current container's live
+    sessions only — historical events evict with the session.
     """
     _check_admin(request, x_admin_password)
+    from backend import session_state as _ss
     events: list[dict] = []
-    if not _PROFILES_DIR_FOR_DRIFT.exists():
-        return {"events": [], "total": 0,
-                "snapshot_ts": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")}
-
-    for p in _PROFILES_DIR_FOR_DRIFT.glob("*.json"):
-        try:
-            raw = json.loads(p.read_text())
-        except Exception:
-            continue
-        profile = raw.get("profile") or {}
-        persona_id = raw.get("persona_id") or raw.get("name_slug") or p.stem
-        name_display = raw.get("name_display") or "—"
-        for evt_type, field_name in (("shown", "shown_policies"),
-                                     ("selected", "selected_policies"),
-                                     ("rejected", "rejected_policies")):
-            for entry in (profile.get(field_name) or []):
-                events.append({
-                    "persona_id":   persona_id,
-                    "name_display": name_display,
-                    "event_type":   evt_type,
-                    "policy_slug":  entry.get("policy_slug"),
-                    "insurer":      entry.get("insurer"),
-                    "event_at":     entry.get("event_at"),
-                    "session_id":   entry.get("session_id"),
-                    "reason":       entry.get("reason"),
-                    # Outcome label is the raw event_type — operator decides
-                    # what 'shown without follow-up' means in their context.
-                    "outcome":      evt_type,
-                })
+    with _ss._lock:
+        for sid, s in list(_ss._sessions.items()):
+            p = s.profile
+            name_display = (getattr(p, "name", None) or "—")
+            for evt_type, field_name in (("shown", "shown_policies"),
+                                         ("selected", "selected_policies"),
+                                         ("rejected", "rejected_policies")):
+                for entry in (getattr(p, field_name, None) or []):
+                    events.append({
+                        "persona_id":   sid,
+                        "name_display": name_display,
+                        "event_type":   evt_type,
+                        "policy_slug":  (entry or {}).get("policy_slug"),
+                        "insurer":      (entry or {}).get("insurer"),
+                        "event_at":     (entry or {}).get("event_at"),
+                        "session_id":   (entry or {}).get("session_id"),
+                        "reason":       (entry or {}).get("reason"),
+                        "outcome":      evt_type,
+                    })
     events.sort(key=lambda e: (e["event_at"] or ""), reverse=True)
     events = events[:10]
     return {

backend/brain_tools.py

@@ -62,6 +62,7 @@ from __future__ import annotations
 
 import json as _json
 import logging
+import time
 from pathlib import Path
 from typing import Any, Optional
 
@@ -1619,45 +1620,41 @@ def mark_recommendation(
     # No profile name → no JSON file to write to (anonymous session). No
     # insurer resolution for a slug → skip that slug. All errors swallowed
     # so a logging failure never breaks the tool reply back to Gemini.
+    # ADR-043 (2026-05-27) — record_policy_event used to write the shown
+    # policy onto the named-profile JSON for cross-session "have I shown
+    # this before" tracking. Cross-session persistence is gone; the
+    # in-memory equivalent (avoid re-pitching within the same session)
+    # is handled by session.last_recommendation_ids / shown_policies on
+    # the live Profile dataclass.
     try:
         profile = getattr(session, "profile", None)
-        profile_name = getattr(profile, "name", None) if profile else None
-        if profile_name and cleaned:
-            from backend.profile_store import record_policy_event
-
+        if profile is not None and cleaned:
+            shown = list(getattr(profile, "shown_policies", None) or [])
+            existing_slugs = {(e or {}).get("policy_slug") for e in shown}
             slug_to_insurer = dict(getattr(session, "slug_to_insurer", {}) or {})
-            seen_slugs: set[str] = set()
             turn_idx = int(getattr(session, "turn_idx", 0) or 0)
             session_id = getattr(session, "session_id", None)
+            now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
             for slug in cleaned:
-                if not slug or slug in seen_slugs:
+                if not slug or slug in existing_slugs:
                     continue
                 insurer = slug_to_insurer.get(slug)
                 if not insurer:
-                    # Couldn't resolve insurer this turn — skip rather than
-                    # write a malformed event.
                     continue
-                seen_slugs.add(slug)
-                try:
-                    record_policy_event(
-                        persona_id_or_name=profile_name,
-                        profile=profile,
-                        event_type="shown",
-                        policy_slug=slug,
-                        insurer=insurer,
-                        session_id=session_id,
-                        reason="shown_in_recommendation",
-                        turn_idx=turn_idx,
-                    )
-                except Exception as inner:  # noqa: BLE001
-                    _log.warning(
-                        "X7 mark_recommendation record_policy_event "
-                        "failed (slug=%s): %s: %s",
-                        slug, type(inner).__name__, str(inner)[:200],
-                    )
+                shown.append({
+                    "policy_slug": slug,
+                    "insurer": insurer,
+                    "event_at": now_iso,
+                    "session_id": session_id,
+                    "reason": "shown_in_recommendation",
+                    "turn_idx": turn_idx,
+                })
+                existing_slugs.add(slug)
+            profile.shown_policies = shown
     except Exception as e:  # noqa: BLE001 — never break the tool reply
         _log.warning(
-            "X7 mark_recommendation shown-event logging failed: %s: %s",
+            "mark_recommendation shown-event logging (in-memory) failed: "
+            "%s: %s",
             type(e).__name__, str(e)[:200],
         )
 

backend/main.py

@@ -422,40 +422,11 @@ async def _quarantine_purge_loop() -> None:
 
 # Single source of truth for "is this profile ready to recommend against".
 # brain_tools._profile_complete uses the same _REQUIRED_FOR_READY tuple; we
-# mirror the call here instead of duplicating the slot list so a future
-# addition (e.g. risk_appetite) only needs to be applied in brain_tools.
-# Distinguishes "first-time capture on turn 1" from "stored profile
-# recalled on turn 1". Both end with a
-# non-empty Profile on the session; only the latter should flip
-# returning_user_recalled. Heuristic: if EVERY currently-filled slot was
-# written THIS turn (i.e. lives in `profile_updates`), the user just typed
-# their facts — NOT a recall. If at least one filled slot is NOT in
-# profile_updates, those slots came from the recall hydration.
-_FEATURE_B_SLOT_LIST: tuple[str, ...] = (
-    "name", "age", "dependents", "location_tier",
-    "income_band", "primary_goal", "health_conditions",
-)
-
-
-def _every_filled_slot_was_set_this_turn(profile, profile_updates: dict) -> bool:
-    """Return True iff every populated slot on `profile` was also set in
-    `profile_updates` this turn. Used by the recall detector to suppress
-    the banner when the user just freshly introduced themselves.
-    """
-    if not isinstance(profile_updates, dict):
-        profile_updates = {}
-    pu = set(profile_updates.keys())
-    any_filled = False
-    for fld in _FEATURE_B_SLOT_LIST:
-        v = getattr(profile, fld, None)
-        if v in (None, "", []):
-            continue
-        any_filled = True
-        if fld not in pu:
-            return False
-    # If nothing was filled at all, "every filled" is vacuously True →
-    # detector should NOT flip returning_user_recalled.
-    return True if any_filled else True
+# _FEATURE_B_SLOT_LIST + _every_filled_slot_was_set_this_turn were the
+# heuristic that distinguished "first-time capture on turn 1" from
+# "stored profile recalled on turn 1" for the returning-user banner.
+# Removed in ADR-043 (2026-05-27) — no cross-session recall, so there is
+# no banner to flip.
 
 
 def _compute_profile_complete(session_id: str) -> bool:
@@ -915,10 +886,6 @@ async def chat(req: ChatRequest, request: Request):
     if preferred_codec not in _allowed_codecs:
         preferred_codec = "audio/wav"
     t_chat0 = time.time()
-    # Pre-turn snapshot for the returning-user-recall detector below.
-    # Defaults match the "no session yet" case.
-    _pre_turn_name: str = ""
-    _pre_turn_idx: int = 0
     # Never let an inner TimeoutError / unhandled exception bubble out of
     # handle_turn as a 500. The whole call is wrapped in an outer 45s
     # budget so even a pathological hang inside handle_turn surfaces as a
@@ -934,13 +901,6 @@ async def chat(req: ChatRequest, request: Request):
             from backend.session_state import get_session
 
             _sb_session = get_session(session_id)
-            # KI-Z7 — snapshot the pre-turn (name, turn_idx) so we can tell
-            # AFTER handle_turn whether the turn-1 name heuristic actually
-            # recalled a stored profile (and stamp ChatResponse accordingly).
-            _pre_turn_name = (
-                getattr(_sb_session.profile, "name", None) or ""
-            ).strip()
-            _pre_turn_idx = int(getattr(_sb_session, "turn_idx", 0) or 0)
             # Once a session has had ANY successful single_brain turn, it
             # must stay on single_brain for the rest of its lifetime.
             # Switching brains mid-stream would discard everything
@@ -1363,75 +1323,9 @@ async def chat(req: ChatRequest, request: Request):
     except Exception:  # noqa: BLE001 — log IO must never block a reply
         pass
 
-    # KI-Z7 (2026-05-15) — Feature A. Auto-persist the live profile to disk
-    # + Chroma AFTER handle_turn returns. brain_tools.save_profile_field
-    # only mutates the in-memory Profile; this flushes the union to the
-    # canonical name-keyed JSON and refreshes the user's profile chunk so a
-    # NEW session can recover the full profile via the turn-1 name recall.
-    # Wrapped in try/except — persistence failure NEVER breaks the reply.
+    # Cross-session profile persistence + returning-user detection removed
+    # in ADR-043 (2026-05-27). Sessions are in-memory only.
     _returning_user_recalled = False
-    try:
-        from backend.session_state import get_session as _get_session_p
-        from backend.profile_persistence import auto_persist_session
-
-        _persist_session = _get_session_p(session_id)
-        await auto_persist_session(_persist_session)
-
-        # KI-Z7 — Feature B detection. The pre-turn snapshot (captured before
-        # single_brain.handle_turn ran) lets us tell whether the turn-1 name
-        # heuristic actually hydrated a stored profile. Conditions:
-        #   (a) this WAS the first turn (pre_turn_idx == 0),
-        #   (b) no name on the profile BEFORE the turn ("" → recalled),
-        #   (c) a name AND at least one other slot are present AFTER the turn.
-        # Frontend uses this flag to render the "Welcome back" banner.
-        if USE_SINGLE_BRAIN:
-            try:
-                # KI-RECALL-FIX (2026-05-16) — PREFER the deterministic signal
-                # single_brain sets on the turn where the user explicitly
-                # affirmed a staged cross-session recall (the confirmation
-                # gate resolves on a LATER turn, so the old turn-1-only
-                # heuristic below could NEVER fire for the real flow — the
-                # banner was unreachable even once recall worked).
-                if getattr(turn, "returning_user_recalled", False):
-                    _returning_user_recalled = True
-                else:
-                    # Legacy heuristic — kept as a fallback for any
-                    # non-confirmation recall path (e.g. a direct hydrate via
-                    # the /api/profile/recall-by-name escape hatch) that
-                    # populates the profile on the first turn without a
-                    # confirm round-trip.
-                    _post_name = (
-                        getattr(_persist_session.profile, "name", None) or ""
-                    ).strip()
-                    _post_has_other_slots = any(
-                        getattr(_persist_session.profile, fld, None) not in (None, "", [])
-                        for fld in (
-                            "age", "dependents", "location_tier",
-                            "income_band", "primary_goal", "health_conditions",
-                        )
-                    )
-                    if (
-                        _pre_turn_idx == 0
-                        and not _pre_turn_name
-                        and _post_name
-                        and _post_has_other_slots
-                        # save_profile_field captures a NEW name on turn 1 too
-                        # — only flag as returning when prior slots came from
-                        # the recall path, NOT from in-this-turn extraction.
-                        # If EVERY filled slot is in profile_updates, it's a
-                        # first-time capture, NOT a recall.
-                        and not _every_filled_slot_was_set_this_turn(
-                            _persist_session.profile, turn.profile_updates,
-                        )
-                    ):
-                        _returning_user_recalled = True
-            except Exception:  # noqa: BLE001
-                pass
-    except Exception as _persist_err:  # noqa: BLE001
-        logging.warning(
-            "auto_persist_session failed (session=%s): %s: %s",
-            session_id, type(_persist_err).__name__, _persist_err,
-        )
 
     # Bug B defense — CitationOut requires page_start/page_end as ints, but
     # single_brain.TurnResult.citations dicts don't carry those fields (its
@@ -2178,15 +2072,13 @@ class SessionClearResponse(BaseModel):
 
 @app.post("/api/session/clear", response_model=SessionClearResponse)
 async def session_clear(req: SessionClearRequest):
-    """KI-196 (ADR-041) — Clean Clear-chat semantic. Wipes the in-memory
-    session state for the supplied session_id and ALWAYS returns a freshly
-    minted UUID the frontend must adopt as its new session_id going forward.
+    """Clean Clear-chat semantic. Wipes the in-memory session state for the
+    supplied session_id and ALWAYS returns a freshly minted UUID the
+    frontend must adopt as its new session_id going forward.
 
-    The on-disk profile JSON under `40-data/profiles/` is intentionally NOT
-    touched — it remains durable user data keyed by persona_id / name slug.
-    The next time the user volunteers their name in conversation, the
-    confirmation-gated recall flow (see session_state's
-    `pending_profile_recall`) will ask before merging the prior captures.
+    Post-ADR-043 (2026-05-27) there is nothing to preserve across sessions
+    — there is no on-disk profile to "leave intact". A clear is a complete
+    forget.
 
     Body : {session_id: str}
     Reply: {cleared: bool, new_session_id: str}
@@ -2237,7 +2129,6 @@ async def profile_update(req: ProfileUpdateRequest):
     """
     from backend.scorecard import profile_completeness as _completeness
     from backend.session_state import get_session
-    from backend.profile_rag import upsert_profile_chunk
 
     sess = get_session(req.session_id)
     # Update only fields the client explicitly sent (non-None) — keeps partial
@@ -2261,14 +2152,9 @@ async def profile_update(req: ProfileUpdateRequest):
         if field_name not in sess.profile.asked:
             sess.profile.asked.append(field_name)
 
-    # KI-077 — if name is set, also persist to the named-profile store so a
-    # returning visitor's profile is recoverable across sessions.
-    if req.name:
-        try:
-            from backend.profile_store import save_profile
-            save_profile(req.name, sess.profile, session_id=req.session_id)
-        except Exception as e:
-            print(f"[profile_store] save failed for {req.name}: {type(e).__name__}: {e}")
+    # ADR-043 (2026-05-27) — cross-session persistence + profile_rag
+    # upsert removed. The captured fields live only in the in-memory
+    # SessionState for this session's lifetime (1 h idle TTL).
 
     p = sess.profile
     # KI-271 — SLOT_UNION-driven profile_dict (15 fields) so copay_pct +
@@ -2286,20 +2172,8 @@ async def profile_update(req: ProfileUpdateRequest):
     collected = [k for k, v in profile_dict.items() if k in answered and v not in (None, "", [], False)]
     missing = [k for k, v in profile_dict.items() if k not in answered or v in (None, "", [])]
 
-    # Ingest the profile into the RAG store so the brain sees user context
-    # at retrieval time alongside policy + regulatory chunks. Fire-and-forget
-    # — a profile upsert failure shouldn't block the API response.
-    # KI-118 (2026-05-15) — gated on a known name; anonymous saves don't
-    # write to Chroma. The chunk is keyed by canonical name slug, not the
-    # session_id which is now opaque/in-memory.
-    try:
-        if p.name:
-            from backend.profile_store import _normalise_name
-            name_slug = _normalise_name(p.name)
-            if name_slug:
-                await upsert_profile_chunk(name_slug, profile_dict)
-    except Exception as e:
-        print(f"[profile_rag] upsert failed for {req.session_id}: {type(e).__name__}: {e}")
+    # profile_rag upsert removed in ADR-043 (2026-05-27). Captured fields
+    # remain in the in-memory SessionState only.
 
     return ProfileCompletenessResponse(
         completeness=c,
@@ -4783,56 +4657,11 @@ async def predicted_premium_band(session_id: Optional[str] = None):
     return PredictedPremiumBandResponse(**band)
 
 
-# ---------------------------------------------------------------------------
-# KI-Z7 (2026-05-15) — Feature B. POST /api/profile/recall-by-name.
-#
-# The chat hot path runs the same recall heuristic server-side inside
-# single_brain.handle_turn (turn-1 name sniff + try_recall_by_name) and
-# stamps `returning_user_recalled` on the ChatResponse, so the frontend
-# usually doesn't need this endpoint. It exists as an explicit, idempotent
-# escape hatch — e.g. the user types their name into the profile builder
-# AFTER turn 1 and we want to load their stored facts without sending a
-# chat turn. The hydration is server-side: the in-memory session_state for
-# `session_id` is mutated in place, so the next /api/chat turn already sees
-# the recalled slots.
-# ---------------------------------------------------------------------------
-class RecallByNameRequest(BaseModel):
-    name: str = Field(..., description="User-provided name (display form OK).")
-    session_id: str = Field(..., description="Session id to hydrate on a hit.")
-
-
-class RecallByNameResponse(BaseModel):
-    found: bool
-    # The endpoint does not hydrate the session off a bare name (weak/shared
-    # key → stranger-PII leak). When a stored profile matches, the response
-    # asks the UI to confirm identity FIRST. `profile`/`predicted_band` are
-    # never returned pre-confirmation.
-    requires_confirmation: bool = False
-    name: Optional[str] = None          # stored display name, for the prompt
-    summary: Optional[dict] = None      # non-PII identity hints, for the prompt
-    profile: Optional[dict] = None      # always None until user confirms
-    predicted_band: Optional[dict] = None  # always None until user confirms
-    session_id: str
-
-
-@app.post("/api/profile/recall-by-name", response_model=RecallByNameResponse)
-async def recall_profile_by_name(req: RecallByNameRequest):
-    """Stage a stored named-profile match for `session_id` (if any).
-
-    A bare name is a weak, shared, guessable key, so this endpoint does not
-    auto-hydrate the session — a second user on a shared browser/IP, or
-    anyone stating a common first name, must not be silently served a
-    stranger's stored profile. When a match exists the response carries
-    `found=True, requires_confirmation=True, name, summary` so the UI
-    renders an explicit "are you <name>?" prompt. The stored fields are
-    applied to the session only after the user confirms (handled on the
-    chat affirmation path via session_state.apply_pending_recall). Returns
-    `found=False` when the slug doesn't resolve to a stored file.
-    """
-    from backend.profile_persistence import recall_by_name_payload
-
-    payload = await recall_by_name_payload(req.name, req.session_id)
-    return RecallByNameResponse(**payload)
+# /api/profile/recall-by-name was REMOVED in ADR-043 (2026-05-27).
+# Cross-session profile recall is gone — sessions are in-memory only, so
+# there is nothing to "recall" off a bare name. The frontend api.ts caller
+# that wrapped this endpoint has also been removed. Old clients still
+# pinging the path get a 404, which is the correct degraded behaviour.
 
 
 # ---- Static frontend (served alongside /api on the same port for HF Spaces) ----

backend/profile_persistence.py

@@ -1,339 +0,0 @@
-"""Post-turn auto-persistence + returning-user recall helpers.
-
-Coupled features (KI-Z7, 2026-05-15):
-
-  Feature A — auto_persist_session(session)
-    Called from /api/chat AFTER single_brain.handle_turn returns and BEFORE
-    the ChatResponse is built. Reads the union of all 13 slot_union fields
-    from session.profile and pushes them to:
-      - profile_store.save_profile(...)      — canonical JSON on disk
-      - profile_rag.upsert_profile_chunk(...) — Chroma vector chunk
-    Gated on session.profile.name being non-empty (anonymous turns never
-    persist — KI-118).
-
-    Wrapped in try/except internally; persistence failure NEVER raises and
-    NEVER affects the reply path.
-
-  Feature B — extract_potential_name(text)
-    Cheap regex heuristic that recovers a first name from a turn-1 user
-    utterance ("Hi I'm Priya", "My name is Rajesh", "Anjali here"). Returns
-    None when no clear name is present (e.g. "I'm 34 years old"). Used by
-    single_brain.handle_turn so a returning user is recognised BEFORE
-    Gemini's first tool-call iteration.
-
-  Feature B — try_recall_by_name(session, name)
-    PRIVACY FIX (2026-05-16, audit). Previously this hydrated every empty
-    slot on session.profile and returned True so single_brain stamped
-    `is_returning_user=True` / a "Welcome back" greeting — on a FRESH,
-    no-cookie session, keyed only on the user-stated name. A second user
-    on a shared browser/IP, or anyone stating a common first name, was
-    served a stranger's captured profile. Now it delegates to
-    session_state.rehydrate_by_name which STAGES the match on
-    `session.pending_profile_recall` (no merge, no greeting) and ALWAYS
-    returns False. The stored profile is applied ONLY after an explicit
-    user confirmation via session_state.apply_pending_recall(session,
-    confirmed=True). Same-session continuity is unaffected — slots captured
-    within the live conversation never travel this path.
-
-  Feature B — recall_by_name_payload(name, session_id)
-    Builds the response payload for the POST /api/profile/recall-by-name
-    endpoint. PRIVACY FIX (2026-05-16): this NO LONGER auto-hydrates the
-    live session. A name match is STAGED; the payload reports
-    {found, requires_confirmation, name, summary, session_id} so the UI
-    renders an explicit "are you <name>?" confirm rather than silently
-    adopting a stranger's stored profile. The stored fields are applied to
-    the session only after the user confirms (the chat affirmation path
-    calls session_state.apply_pending_recall).
-
-Design notes:
-  - This module sits between profile_store + profile_rag and is the SINGLE
-    write path the /api/chat hot loop reaches; brain_tools.save_profile_field
-    still only mutates the in-memory Profile (B6 owns that file).
-  - No async required for the JSON write; profile_rag.upsert_profile_chunk
-    is async (embedder), so auto_persist_session is async too.
-  - All callers MUST await it and swallow exceptions defensively. We do the
-    defensive swallow internally as belt-and-suspenders so callers can
-    simply `await auto_persist_session(session)` without try/except.
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from typing import Any, Optional
-
-_log = logging.getLogger(__name__)
-
-
-# ---------------------------------------------------------------------------
-# Feature A — post-turn persistence
-# ---------------------------------------------------------------------------
-
-
-# The 13 fields that make up the "slot_union" — what we persist on every
-# auto_persist_session call. Kept in sync with the schemas in
-# needs_finder.Profile and brain_tools.save_profile_field's accepted fields.
-_UNION_FIELDS: tuple[str, ...] = (
-    "name",
-    "age",
-    "dependents",
-    "income_band",
-    "existing_cover_inr",
-    "primary_goal",
-    "location_tier",
-    "parents_to_insure",
-    "parents_age_max",
-    "parents_has_ped",
-    "health_conditions",
-    "budget_band",
-    "desired_sum_insured_inr",
-)
-
-
-def _build_union_dict(profile) -> dict[str, Any]:
-    """Build the persistence payload — dict of all 13 union fields."""
-    return {f: getattr(profile, f, None) for f in _UNION_FIELDS}
-
-
-async def auto_persist_session(session) -> bool:
-    """Persist the live session profile to disk + Chroma.
-
-    No-op (returns False) when:
-      - session is None
-      - session.profile.name is empty / None
-      - either underlying write raises (logged, then swallowed)
-
-    Returns True iff BOTH save_profile() AND upsert_profile_chunk() ran
-    without raising. Persistence failure NEVER bubbles out — the chat
-    reply must not be blocked by a stuck disk or a Chroma hiccup.
-    """
-    if session is None:
-        return False
-    profile = getattr(session, "profile", None)
-    if profile is None:
-        return False
-    name = (getattr(profile, "name", None) or "").strip()
-    if not name:
-        # Anonymous turn — never write to disk, never embed (KI-118).
-        return False
-
-    union = _build_union_dict(profile)
-    saved_json = False
-    saved_chunk = False
-
-    # 1) Canonical JSON on disk.
-    try:
-        from backend.profile_store import save_profile
-
-        saved_json = save_profile(
-            name,
-            profile,
-            session_id=getattr(session, "session_id", None),
-        )
-    except Exception as e:  # noqa: BLE001
-        _log.warning(
-            "auto_persist_session: save_profile failed (name=%r): %s: %s",
-            name, type(e).__name__, str(e)[:200],
-        )
-
-    # 2) Vector chunk (gated on a derivable name_slug — same gate as the
-    #    POST /api/profile path).
-    try:
-        from backend.profile_store import _normalise_name
-        from backend.profile_rag import upsert_profile_chunk
-
-        name_slug = _normalise_name(name)
-        if name_slug:
-            await upsert_profile_chunk(name_slug, union)
-            saved_chunk = True
-    except Exception as e:  # noqa: BLE001
-        _log.warning(
-            "auto_persist_session: upsert_profile_chunk failed (name=%r): %s: %s",
-            name, type(e).__name__, str(e)[:200],
-        )
-
-    return saved_json and saved_chunk
-
-
-# ---------------------------------------------------------------------------
-# Feature B — turn-1 name heuristic + returning-user recall
-# ---------------------------------------------------------------------------
-
-
-# Match an explicit self-introduction. Three forms cover the common cases:
-#   1. "I'm <name>" / "I am <name>"
-#   2. "My name is <name>" / "this is <name>"
-#   3. "<name> here"
-# We deliberately require a verb-ish anchor — bare "Priya." with no
-# surrounding context is too noisy on turn 1 (it could be a question subject)
-# and the existing brain_tools.save_profile_field path will pick it up
-# safely if the user repeats it.
-_NAME_RE = re.compile(
-    r"""
-    (?:
-        \b(?:i\s*am|i'?m|my\s+name\s+is|this\s+is|name'?s)\s+
-        (?P<n1>[A-Z][a-zA-Z]{1,30}(?:\s+[A-Z][a-zA-Z]{1,30})?)
-        \b
-      |
-        ^\s*(?P<n2>[A-Z][a-zA-Z]{1,30}(?:\s+[A-Z][a-zA-Z]{1,30})?)\s+here\b
-    )
-    """,
-    re.VERBOSE | re.IGNORECASE,
-)
-
-# Words that look name-like to the regex (capitalised at sentence start)
-# but are NOT names. Filter post-match so "I'm 34" and "I am okay" never
-# resolve to "okay" / "34" as a name.
-_NAME_STOPWORDS: set[str] = {
-    "ok", "okay", "fine", "good", "great", "well", "yes", "no", "yeah",
-    "nope", "sure", "looking", "trying", "thinking", "interested",
-    "here", "back", "ready", "done", "free", "busy", "tired", "young",
-    "old", "married", "single", "alone", "happy", "sad",
-    "from", "in", "at", "on", "with", "for", "to",
-    "the", "a", "an",
-    # Time + age
-    "twenty", "thirty", "forty", "fifty", "sixty",
-}
-
-
-def extract_potential_name(text: str) -> Optional[str]:
-    """Return a probable first-name capture from a turn-1 user utterance.
-
-    Examples:
-        "Hi I'm Priya"            -> "Priya"
-        "Hello, my name is Rajesh" -> "Rajesh"
-        "Anjali here"             -> "Anjali"
-        "I'm 34 years old"        -> None
-        "I am okay, thanks"       -> None
-        ""                        -> None
-
-    Caller should slug + try_recall_by_name; no DB or LLM cost.
-    """
-    if not text or not text.strip():
-        return None
-    # Normalize whitespace, keep original casing for the regex.
-    s = text.strip()
-    m = _NAME_RE.search(s)
-    if not m:
-        return None
-    raw = (m.group("n1") or m.group("n2") or "").strip()
-    if not raw:
-        return None
-    # Reject digit-laden captures ("I'm 34") and stop-words ("I'm okay").
-    first_token = raw.split()[0]
-    if first_token.lower() in _NAME_STOPWORDS:
-        return None
-    if not first_token.isalpha():
-        return None
-    if len(first_token) < 2:
-        return None
-    return raw
-
-
-def try_recall_by_name(session, name: str, *, user_text: str = "") -> bool:
-    """Look up a stored profile by name and STAGE it for confirmation.
-
-    PRIVACY FIX (2026-05-16). Wraps session_state.rehydrate_by_name, which
-    now STAGES a name match on `session.pending_profile_recall` instead of
-    auto-merging it into `session.profile`. Nothing is applied to the live
-    session here.
-
-    PRIVACY HARDENING v4 (2026-05-27, ADR-042 follow-up #1) — `user_text`
-    is threaded through so the two-fact gate inside rehydrate_by_name can
-    parse same-turn identity facts (age/dependents/location/income) to
-    decide whether to stage / defer / fail-closed. Callers that don't have
-    user_text on hand (rare) still get the prior-turn live-profile path.
-
-    Returns:
-        Always False — the stored profile is NEVER auto-applied. The
-        single_brain caller therefore never stamps `is_returning_user` /
-        a "Welcome back" greeting off a bare name on a fresh session.
-        Whether a match was *staged* is observable on
-        `session.pending_profile_recall`; whether the probe was *deferred*
-        (no facts to disambiguate yet) is on `session.recall_match_deferred`.
-        The brain surfaces an "are you <name>?" confirm and calls
-        session_state.apply_pending_recall on the user's explicit answer.
-    """
-    if not name or not name.strip():
-        return False
-    try:
-        from backend.session_state import rehydrate_by_name
-
-        return bool(rehydrate_by_name(session, name, user_text=user_text))
-    except Exception as e:  # noqa: BLE001
-        _log.warning(
-            "try_recall_by_name failed (name=%r): %s: %s",
-            name, type(e).__name__, str(e)[:200],
-        )
-        return False
-
-
-async def recall_by_name_payload(
-    name: str,
-    session_id: str,
-) -> dict[str, Any]:
-    """Build the response payload for POST /api/profile/recall-by-name.
-
-    PRIVACY FIX (2026-05-16, audit). This NO LONGER hydrates the live
-    session. A bare name is a weak, shared, guessable key; auto-applying a
-    stored profile to a fresh, no-cookie session leaked stranger PII. A
-    match is now STAGED on `session.pending_profile_recall`; the payload
-    asks the UI to confirm identity before anything is applied.
-
-    Returns:
-        {
-          "found": bool,                  # True iff a stored match exists
-          "requires_confirmation": bool,  # True when found (never auto-apply)
-          "name": str | None,             # stored display name (for the prompt)
-          "summary": dict | None,         # non-PII identity hints for the prompt
-          "profile": None,                # NEVER returned pre-confirmation
-          "predicted_band": None,         # NEVER returned pre-confirmation
-          "session_id": str,
-        }
-
-    No side effect on `session.profile`. The staged match is applied only
-    after the user explicitly confirms, via the chat affirmation path
-    (session_state.apply_pending_recall).
-    """
-    out: dict[str, Any] = {
-        "found": False,
-        "requires_confirmation": False,
-        "name": None,
-        "summary": None,
-        "profile": None,
-        "predicted_band": None,
-        "session_id": session_id,
-    }
-    if not name or not name.strip() or not session_id:
-        return out
-
-    try:
-        from backend.session_state import get_session
-
-        sess = get_session(session_id)
-    except Exception as e:  # noqa: BLE001
-        _log.warning(
-            "recall_by_name_payload: get_session failed (session_id=%r): %s: %s",
-            session_id, type(e).__name__, str(e)[:200],
-        )
-        return out
-
-    # Stages on sess.pending_profile_recall; ALWAYS returns False (no merge).
-    try_recall_by_name(sess, name)
-    pending = getattr(sess, "pending_profile_recall", None)
-    if not pending:
-        return out
-
-    out["found"] = True
-    out["requires_confirmation"] = True
-    out["name"] = pending.get("name")
-    out["summary"] = pending.get("summary")
-    return out
-
-
-__all__ = [
-    "auto_persist_session",
-    "extract_potential_name",
-    "try_recall_by_name",
-    "recall_by_name_payload",
-]

backend/profile_rag.py

@@ -1,241 +0,0 @@
-"""Customer-profile-as-RAG layer.
-
-Profile chunks are keyed by `name_slug` (the canonicalised user name),
-NOT by session_id. Only NAMED users ever get embedded; anonymous sessions
-never write to Chroma. Keying by name_slug avoids the corruption surface
-of session_id-keyed chunks (an anonymous row missing a session_id
-metadata field could poison session_id-scoped retrieval queries).
-
-At retrieval time, `rag/retrieve.py::retrieve(..., profile_name_slug=...)`
-boosts the user's profile chunk so the LLM sees the user's context inline
-with the retrieved policy/regulatory text — answers become personalised at
-the BRAIN level, not just at scorecard re-weighting.
-
-Public API:
-    profile_to_chunk_text(profile_dict) -> str
-        Render the structured profile as a single English paragraph.
-    upsert_profile_chunk(name_slug, profile_dict, embedder) -> None
-        Ingest / update the chunk for this named user in Chroma.
-    remove_profile_chunk(name_slug) -> None
-        Optional cleanup.
-
-Storage model — one chunk per name_slug. Replaced on each profile update.
-Profile chunks live in the SAME collection as policies so retrieval can
-naturally surface them when scoring policies for the user.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from typing import Optional
-
-from backend.config import settings
-
-_log = logging.getLogger(__name__)
-
-
-def profile_to_chunk_text(profile: dict) -> str:
-    """Render the profile dict as a natural-language paragraph for the LLM.
-
-    Rendered as a coherent "USER CONTEXT" block so that when this chunk is
-    retrieved alongside policy chunks, the LLM sees the user's facts inline.
-    """
-    parts: list[str] = ["USER CONTEXT — facts about the person asking this question:"]
-
-    age = profile.get("age")
-    if isinstance(age, int):
-        parts.append(f"- Age: {age} years.")
-
-    deps = profile.get("dependents")
-    if isinstance(deps, str) and deps:
-        parts.append(f"- Covering: {deps.replace('_', ' ').replace('+', ' + ')}.")
-
-    parents_age = profile.get("parents_age_max")
-    parents_ped = profile.get("parents_has_ped")
-    if parents_age:
-        parents_line = f"- Older parent's age: {parents_age}."
-        if parents_ped is True:
-            parents_line += " Parents have pre-existing conditions (diabetes / BP / heart etc.)."
-        elif parents_ped is False:
-            parents_line += " Parents are healthy with no flagged conditions."
-        parts.append(parents_line)
-
-    conditions = profile.get("health_conditions")
-    if isinstance(conditions, list) and conditions:
-        cstr = ", ".join(str(c) for c in conditions)
-        parts.append(f"- User's own pre-existing conditions: {cstr}.")
-    elif conditions == []:
-        parts.append("- User has no pre-existing conditions disclosed.")
-
-    existing = profile.get("existing_cover_inr")
-    if existing == 0:
-        parts.append("- First-time buyer; no existing health insurance.")
-    elif isinstance(existing, int) and existing > 0:
-        if existing >= 100000:
-            parts.append(f"- Already has ₹{existing // 100000}L of existing health cover.")
-        else:
-            parts.append(f"- Already has ₹{existing} of existing health cover.")
-
-    goal = profile.get("primary_goal")
-    if isinstance(goal, str) and goal:
-        goal_str = goal.replace("_", " ")
-        parts.append(f"- Goal today: {goal_str}.")
-
-    loc = profile.get("location_tier")
-    if isinstance(loc, str) and loc:
-        parts.append(f"- City tier: {loc}.")
-
-    budget = profile.get("budget_band")
-    if isinstance(budget, str) and budget:
-        parts.append(f"- Annual premium budget: {budget.replace('_', '-').replace('-', ' - ')}.")
-
-    income = profile.get("income_band")
-    if isinstance(income, str) and income:
-        parts.append(f"- Annual income band: {income}.")
-
-    if len(parts) == 1:
-        return "USER CONTEXT — no profile info collected yet."
-    parts.append(
-        "Use these facts when scoring or recommending. The user has consented to share them; "
-        "honesty about conditions protects their later claim, so weight disclosed conditions "
-        "explicitly in the recommendation rationale."
-    )
-    return "\n".join(parts)
-
-
-def _get_collection():
-    """Lazy-import Chroma to keep startup time low when not needed."""
-    import chromadb
-    from chromadb.config import Settings as ChromaSettings
-
-    client = chromadb.PersistentClient(
-        path=str(settings.VECTORS_DIR),
-        settings=ChromaSettings(anonymized_telemetry=False),
-    )
-    return client.get_or_create_collection(
-        name="policies",
-        metadata={"hnsw:space": "cosine"},
-    )
-
-
-async def upsert_profile_chunk(name_slug: str, profile_dict: dict) -> None:
-    """Embed the profile paragraph and store as a single chunk in Chroma.
-
-    Keyed by `name_slug` (canonical user name), not `session_id`. Only
-    NAMED users ever get embedded — anonymous chats never write to Chroma.
-
-    Idempotent — calling this on every profile update is safe; existing
-    chunks for the same name_slug get replaced.
-    """
-    from backend.providers.local_embeddings import LocalEmbeddings
-
-    text = profile_to_chunk_text(profile_dict)
-    if not text or len(text) < 30:
-        return
-
-    # Input guard 1: name_slug must be a non-empty str. An empty key would
-    # upsert under id "profile_" and collide across anonymous sessions.
-    # Callers gate on `session.profile.name` before calling, so anonymous
-    # users do not reach this function; this guard is belt-and-braces.
-    if not isinstance(name_slug, str) or not name_slug.strip():
-        _log.warning(
-            "profile_rag.upsert_profile_chunk: refusing to write — name_slug "
-            "must be a non-empty str, got %r. Profile not persisted.",
-            name_slug,
-        )
-        return
-
-    embedder = LocalEmbeddings()
-    [vec] = await embedder.embed([text], input_type="document")
-
-    # Input guard 2: embedding must be a list of finite floats whose length
-    # matches the embedder's declared dimension. An empty / None / mis-shaped
-    # embedding added to Chroma would silently corrupt HNSW (dangling
-    # pointer or shape mismatch). The corpus uses 384-dim
-    # BAAI/bge-small-en-v1.5; any other shape is rejected.
-    expected_dim = getattr(embedder, "dimension", None) or 384
-    if (
-        not isinstance(vec, (list, tuple))
-        or len(vec) != expected_dim
-        or any((v is None) for v in vec)
-    ):
-        _log.warning(
-            "profile_rag.upsert_profile_chunk: refusing to write — embedding "
-            "shape invalid for name_slug=%s (expected %d-dim list of floats, "
-            "got type=%s len=%s). Profile not persisted.",
-            name_slug, expected_dim, type(vec).__name__,
-            (len(vec) if hasattr(vec, "__len__") else "?"),
-        )
-        return
-
-    coll = _get_collection()
-    chunk_id = f"profile_{name_slug}"
-
-    # Replace any existing chunk for this name
-    try:
-        coll.delete(where={"policy_id": chunk_id})
-    except Exception as e:
-        # Non-fatal: chunk may not exist yet. Log so a silent failure of
-        # the profile store is observable.
-        _log.debug(
-            "profile_rag.upsert_profile_chunk: delete(where=policy_id=%s) "
-            "non-fatal failure: %s: %s",
-            chunk_id, type(e).__name__, str(e)[:200],
-        )
-
-    # Wrap coll.add() in try/except so upsert is non-fatal: a transient
-    # Chroma sqlite lock during HNSW compaction (add() interleaving with
-    # the retrieve path's get()) must not break the chat reply. The next
-    # upsert (next profile field change) retries the write.
-    try:
-        coll.add(
-            ids=[chunk_id],
-            documents=[text],
-            embeddings=[vec],
-            metadatas=[{
-                "policy_id": chunk_id,
-                "insurer_slug": "profile",
-                "policy_name": f"User profile ({name_slug[:16]})",
-                "doc_type": "profile",
-                # Stamp name_slug; the retrieve path filters profile
-                # chunks via this field.
-                "name_slug": name_slug,
-                "source_url": "",
-                "page_start": 0,
-                "page_end": 0,
-                "chunk_idx": 0,
-                "local_path": "in-memory named-profile chunk",
-            }],
-        )
-    except Exception as e:
-        _log.warning(
-            "profile_rag.upsert_profile_chunk: add(id=%s) failed: %s: %s — "
-            "user reply will proceed without per-user profile context; "
-            "next profile change will retry.",
-            chunk_id, type(e).__name__, str(e)[:200],
-        )
-
-
-def remove_profile_chunk(name_slug: str) -> None:
-    """Optional cleanup. Keyed by name_slug."""
-    if not name_slug:
-        return
-    try:
-        coll = _get_collection()
-        coll.delete(where={"policy_id": f"profile_{name_slug}"})
-    except Exception:
-        pass
-
-
-def upsert_profile_chunk_sync(name_slug: str, profile_dict: dict) -> None:
-    """Sync wrapper for callers that aren't async — schedules + waits."""
-    try:
-        loop = asyncio.get_event_loop()
-        if loop.is_running():
-            # Already inside an async context — schedule on the loop
-            asyncio.ensure_future(upsert_profile_chunk(name_slug, profile_dict))
-            return
-    except RuntimeError:
-        pass
-    asyncio.run(upsert_profile_chunk(name_slug, profile_dict))

backend/profile_store.py

@@ -1,394 +0,0 @@
-"""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
-save path also fires `profile_rag.upsert_profile_chunk()` so the Chroma
-side reflects the new state.
-
-Files live under `40-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 hashlib
-import json
-import logging
-import re
-import time
-from dataclasses import asdict
-from pathlib import Path
-from typing import Literal, Optional
-
-from backend.config import settings
-from backend.needs_finder import Profile
-
-_PROFILES_DIR = settings.DATA_DIR / "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
-
-
-# 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
-    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_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 path=%s: %s", p, 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 path=%s: %s", p, e)
-        return None
-
-
-def load_profile(name: str, *, persona_id: Optional[str] = None) -> Optional[Profile]:
-    """Return the stored Profile for `name` (and optional `persona_id`).
-
-    Lookup order (KI-062, 2026-05-15; PRIVACY-HARDENED 2026-05-16):
-      1. If `persona_id` given, try that exact file.
-      2. Try the name-slug file (legacy + first-visit path before
-         identity fields are known).
-
-    PRIVACY FIX (2026-05-16, audit). A former step 3 scanned the WHOLE
-    profiles directory and returned any persona-id-keyed file whose stored
-    `name_display` matched the requested name slug. That was a pure
-    cross-identity leak: a fresh, no-cookie visitor stating a common first
-    name ("I'm Rahul") pulled a *stranger's* persona-id profile (different
-    age / city / dependents) — exactly the audit's "Welcome back, Rahul"
-    finding. The directory scan is removed entirely.
-
-    KI-RECALL-FIX (2026-05-16). The privacy fix above, on its own, made
-    cross-session recall structurally DEAD: `save_profile` graduates to a
-    persona-id-keyed file the moment the user gives a name + ANY identity
-    fact (which the fact-find always asks immediately), so the bare
-    name-slug file `<slug>.json` never existed and step 2 always missed.
-    Five real "Rohit" profiles existed on disk, all persona-id-keyed, none
-    recoverable by the chat-path bare-name lookup → the "Welcome back"
-    banner was unreachable for every returning user.
-
-    The fix keeps the privacy boundary where it belongs (the explicit
-    "are you the same <name>?" confirm gate in single_brain /
-    session_state.apply_pending_recall) and restores recall by making
-    `save_profile` ALWAYS also write a `<slug>.json` recall pointer that
-    carries the user's most-recently-seen profile under that name. So:
-
-      • step 2 (slug file) resolves a real returning user's OWN most-recent
-        profile — enough to STAGE the confirm prompt. Nothing is merged
-        into the live session until the user explicitly says "yes that's
-        me" (session_state.apply_pending_recall), so a stranger stating a
-        common name is asked to confirm and, on anything other than a
-        clear yes, gets NOTHING (fail-closed).
-      • the cross-identity DIRECTORY SCAN stays removed — we never pick an
-        arbitrary persona-id file by matching display names. We only ever
-        read the deterministic slug file (the user's own pointer) or the
-        caller's own persona_id.
-    """
-    # 1. Direct persona-id hit (the caller's OWN id, never inferred here).
-    if persona_id:
-        p = _path_for(name, persona_id=persona_id)
-        if p and p.exists():
-            return _load_from_path(p)
-    # 2. Name-slug recall pointer (this user's own most-recent profile under
-    #    this name — written on EVERY save by save_profile). Safe to return
-    #    for *staging*: the session layer gates the actual merge behind an
-    #    explicit user confirmation, so a same-name stranger leaks nothing.
-    p = _path_for(name)
-    if p and p.exists():
-        return _load_from_path(p)
-    # No cross-identity display-name directory scan (would be a leak vector).
-    return None
-
-
-def _atomic_write_json(p: Path, payload: dict) -> None:
-    """Write `payload` to `p` atomically (tmp + replace)."""
-    tmp = p.with_suffix(".json.tmp")
-    tmp.write_text(json.dumps(payload, indent=2, default=str))
-    tmp.replace(p)
-
-
-def save_profile(name: str, profile: Profile, *, session_id: Optional[str] = None) -> bool:
-    """Persist `profile`.
-
-    KI-062 (2026-05-15): the CANONICAL, disambiguated copy is 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.
-
-    KI-RECALL-FIX (2026-05-16): we ALSO always write a `<slug>.json` recall
-    POINTER carrying the most-recently-seen profile under this name. Without
-    it, cross-session recall was structurally dead — `load_profile(name)` on
-    the chat path has no persona_id, the persona-id file is unreachable by
-    bare name, the privacy fix removed the directory scan, and the bare-slug
-    file was being *deleted* on graduation. The pointer is the deterministic
-    entry point a real returning user (typing their own name) is resolved by;
-    the actual merge into a live session stays gated behind the explicit
-    "are you the same <name>?" confirmation (session_state.apply_pending_recall),
-    so a same-name stranger still leaks nothing.
-
-    When no persona_id can be derived (name only, no identity facts yet) the
-    slug file IS the canonical file and we write it once.
-    """
-    slug = _normalise_name(name)
-    if not slug:
-        return False
-    persona_id = compute_persona_id(profile)
-    canonical = _path_for(name, persona_id=persona_id) if persona_id else _path_for(name)
-    slug_path = _path_for(name)
-    if not canonical or not slug_path:
-        return False
-    try:
-        _PROFILES_DIR.mkdir(parents=True, exist_ok=True)
-        existing: dict = {}
-        if canonical.exists():
-            try:
-                existing = json.loads(canonical.read_text())
-            except Exception:
-                existing = {}
-        # KI-062 / KI-RECALL-FIX — when graduating from a slug-keyed file to a
-        # persona-id-keyed file, carry the slug file's session history forward
-        # so it isn't orphaned. We DO NOT delete the slug file anymore — it is
-        # rewritten below as the recall pointer.
-        if persona_id and slug_path.resolve() != canonical.resolve() and slug_path.exists():
-            try:
-                leg_raw = json.loads(slug_path.read_text())
-                existing.setdefault("sessions", [])
-                for s in list(leg_raw.get("sessions") or []):
-                    if s not in existing["sessions"]:
-                        existing["sessions"].append(s)
-                if not existing.get("first_seen"):
-                    existing["first_seen"] = leg_raw.get("first_seen")
-            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:
-            sessions.append(session_id)
-            sessions = sessions[-20:]  # keep last 20 only
-        payload = {
-            "name_display": (profile.name or name).strip(),
-            "name_slug": slug,
-            "persona_id": persona_id,  # KI-062
-            "profile": asdict(profile),
-            "first_seen": existing.get("first_seen") or now_iso,
-            "last_seen": now_iso,
-            "sessions": sessions,
-        }
-        # 1) Canonical (persona-id-keyed when disambiguated, else slug).
-        _atomic_write_json(canonical, payload)
-        # 2) Recall pointer — always keep <slug>.json pointing at this user's
-        #    MOST-RECENT profile under this name. When canonical IS the slug
-        #    file (no persona_id) step 1 already wrote it; skip the dup write.
-        if slug_path.resolve() != canonical.resolve():
-            pointer = dict(payload)
-            # Breadcrumb so the admin/audit view can see this is a recall
-            # pointer that resolves to a persona-id-keyed canonical file.
-            pointer["recall_pointer"] = True
-            pointer["points_to_persona_id"] = persona_id
-            _atomic_write_json(slug_path, pointer)
-        return True
-    except Exception as e:
-        logging.warning("profile_store save failed name=%s: %s", name, e)
-        return False
-
-
-# ---------------------------------------------------------------------------
-# Per-user policy interaction tracking.
-#
-# Three event types are tracked on the Profile:
-#   shown    — auto-logged by the brain when a policy is cited in a
-#              recommendation / comparison turn that passed faithfulness.
-#   selected — user clicked "save / shortlist" on a policy card (frontend
-#              POSTs to /api/profile/select).
-#   rejected — user clicked "not for me" (frontend POSTs to /api/profile/reject).
-#
-# Each entry persists across sessions on the JSON profile, so a returning
-# visitor sees their shortlist and the bot can avoid re-pitching rejected
-# policies.
-# ---------------------------------------------------------------------------
-
-_EVENT_TYPE_TO_FIELD = {
-    "shown": "shown_policies",
-    "selected": "selected_policies",
-    "rejected": "rejected_policies",
-}
-
-
-def record_policy_event(
-    persona_id_or_name: str,
-    profile: Profile,
-    event_type: Literal["shown", "selected", "rejected"],
-    policy_slug: str,
-    insurer: str,
-    session_id: Optional[str] = None,
-    reason: Optional[str] = None,
-    turn_idx: Optional[int] = None,
-) -> bool:
-    """Append a single policy-interaction event to the profile and persist.
-
-    Dedup: if the SAME `policy_slug` already exists in the matching list for
-    this event_type, the existing entry is updated in place (event_at +
-    session_id refreshed) rather than appending a duplicate. This keeps the
-    list bounded and chronologically meaningful — repeated shows of the same
-    policy collapse to the most recent timestamp.
-
-    Returns True on successful save, False on any failure (missing fields,
-    invalid event type, save error).
-    """
-    if event_type not in _EVENT_TYPE_TO_FIELD:
-        return False
-    if not policy_slug or not insurer:
-        return False
-    field_name = _EVENT_TYPE_TO_FIELD[event_type]
-    entries: list[dict] = list(getattr(profile, field_name, None) or [])
-    now_iso = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
-    default_reason = {
-        "shown": "shown_in_recommendation",
-        "selected": "user_clicked_select",
-        "rejected": "user_clicked_reject",
-    }[event_type]
-    payload = {
-        "policy_slug": policy_slug,
-        "insurer": insurer,
-        "event_at": now_iso,
-        "session_id": session_id,
-        "reason": reason or default_reason,
-    }
-    # X7 — stamp the conversation_turn index when the caller knows it.
-    # Admin Recommendation History reads `conversation_turn` from the event
-    # and falls back to "—" when the field is missing/None. Optional so
-    # legacy callers (frontend /api/profile/select & /reject) stay valid.
-    if turn_idx is not None:
-        payload["turn_idx"] = int(turn_idx)
-    # Dedup on policy_slug within this event-type list. Bump timestamp +
-    # session_id; preserve original reason unless caller passed a new one.
-    dedup_idx = next(
-        (i for i, e in enumerate(entries) if e.get("policy_slug") == policy_slug),
-        None,
-    )
-    if dedup_idx is not None:
-        existing = dict(entries[dedup_idx])
-        existing["event_at"] = now_iso
-        if session_id:
-            existing["session_id"] = session_id
-        if reason:
-            existing["reason"] = reason
-        if turn_idx is not None:
-            existing["turn_idx"] = int(turn_idx)
-        entries[dedup_idx] = existing
-    else:
-        entries.append(payload)
-    setattr(profile, field_name, entries)
-    # Persist through the existing save path so persona-id resolution + Chroma
-    # sync (if any) stay consistent.
-    save_name = profile.name or persona_id_or_name
-    if not save_name:
-        return False
-    return save_profile(save_name, profile, session_id=session_id)
-
-
-def get_shortlist(profile: Profile) -> list[dict]:
-    """Return the user's selected (shortlisted) policies.
-
-    Thin convenience wrapper used by the admin panel + welcome-back greeting
-    so callers don't have to remember the field name.
-    """
-    return list(getattr(profile, "selected_policies", None) or [])
-
-
-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

backend/session_state.py

@@ -5,200 +5,42 @@ intent from scratch. That broke fact-find: after the bot asked "what's
 your age?", the user's "39 years old" wasn't matched by intent_classifier
 and got routed to RAG retrieval (which then refused). This module fixes that.
 
-Persistence model (KI-118, 2026-05-15):
-  - In-memory dict ONLY. No disk persistence.
+Persistence model (ADR-043, 2026-05-27 — REMOVAL of cross-session recall):
+  - In-memory dict ONLY. No disk persistence anywhere.
   - Sessions are evicted from memory after `_TTL_SECONDS = 60 * 60` idle.
-  - Cross-session memory is name-based: when the user provides a name,
-    `rehydrate_by_name(session, name)` pulls the named profile from
-    `backend.profile_store.load_profile(name)` (canonical JSON at
-    `40-data/profiles/<persona_id>.json`).
-  - Anonymous sessions live only in-memory and never leave a trace on disk.
-
-Rationale: insurance shoppers don't multi-session within a browsing window.
-Cross-session memory is name-based. The previous disk-write side
-(`40-data/sessions/<session_id>.json`) was the root of the Chroma
-corruption fought 2026-05-14/15 (profile_anonymous dangling row).
+  - There is no cross-session memory. Closing the tab (or letting the
+    session go idle for an hour) discards the profile permanently.
+  - The previous cross-session recall design (ADR-041 + ADR-042 with
+    name-slug pointers under `40-data/profiles/` plus a confirmation
+    gate, redacted prompts, match-before-merge guards, two-fact gate
+    and same-turn extractors) was removed. The complexity tax was high
+    relative to the use case (insurance is a rare-purchase, return
+    sessions are uncommon), the privacy surface — name-only key with
+    slug-pointer collisions across distinct users — required four
+    sequential hardening passes to keep contained, and the recall path
+    became a recurring bug source. Minimum-data-retention now matches
+    the simpler "stateless advisor" mental model.
 
 Public API:
     get_session(session_id) -> SessionState
-    rehydrate_by_name(session, name) -> bool   # KI-118 cross-session re-entry
-    SessionState.profile, .asked, .awaiting (question id pending answer)
+    SessionState.profile, .awaiting (question id pending answer)
     SessionState.set_awaiting(qid)
-    SessionState.record_answer(qid, raw_answer) → also clears awaiting
+    SessionState.record_user_answer(raw_answer) → also clears awaiting
+    SessionState.update_profile_field(name, value)
+    reset_session(session_id) / clear_session(session_id) — evict in-memory
+    set_free_form(session_id, free_form) — bypass fact-find for this session
 """
 
 from __future__ import annotations
 
 import logging
-import re
 import time
 from dataclasses import dataclass, field
 from threading import Lock
-from typing import Optional
-
-from typing import Any, Dict
+from typing import Any, Dict, Optional
 
 from backend.needs_finder import Profile, record_answer
 
-
-# 2026-05-27 — best-effort identity-fact extractors for the same-turn
-# match-before-merge guard inside `apply_pending_recall` AND for the
-# two-fact gate inside `rehydrate_by_name`. The LLM is the canonical
-# extractor (save_profile_field), but it runs AFTER both call sites in
-# the turn pipeline — so a "Yes I'm 35" / "Hi I'm Rohit, I'm in
-# Mumbai" reply would otherwise either merge the wrong profile or fail
-# to stage a legitimate same-turn recall. Mis-parses return None and
-# cost nothing.
-#
-# Coverage:
-#   age            — _extract_age_from_text
-#   dependents     — _extract_dependents_from_text  (delegates to
-#                    brain_tools._normalize_dependents_inline so the
-#                    canonical bucket set is honored)
-#   location_tier  — _extract_location_tier_from_text  (Indian-city
-#                    name → metro / tier1 / tier2 / tier3 lookup)
-#   income_band    — _extract_income_band_from_text  (delegates to
-#                    needs_finder._parse_income_band)
-
-_AGE_HINT_RE = re.compile(
-    r"\b(?:age\s*[:=]?\s*|i'?m\s+|i\s+am\s+|aged\s+|aged\s*[:=]?\s*)?(\d{2})"
-    r"\s*(?:years?\s*old|yrs?|y/?o)?\b",
-    re.IGNORECASE,
-)
-
-
-def _extract_age_from_text(text: str) -> Optional[int]:
-    """Best-effort age extraction from a free-form user reply.
-    Returns int in [18, 99] or None. Picks the FIRST plausible match —
-    in practice the user states their age once, near the start.
-    """
-    if not text:
-        return None
-    for m in _AGE_HINT_RE.finditer(text):
-        try:
-            v = int(m.group(1))
-            if 18 <= v <= 99:
-                return v
-        except Exception:
-            continue
-    return None
-
-
-def _extract_dependents_from_text(text: str) -> Optional[str]:
-    """Best-effort dependents bucket from free-form text.
-    Delegates to brain_tools._normalize_dependents_inline so the
-    canonical bucket set ("self", "self+spouse", "self+spouse+kids",
-    "self+parents", "self+spouse+parents", "self+spouse+kids+parents",
-    "self+kids") is honored. Returns None on no match.
-    """
-    if not text:
-        return None
-    try:
-        # Lazy import to avoid load-order issues at module init.
-        from backend.brain_tools import _normalize_dependents_inline
-    except Exception:
-        return None
-    try:
-        return _normalize_dependents_inline(text)
-    except Exception:
-        return None
-
-
-# Indian-city → tier lookup. Tier-1 list per the IRDAI / RBI city
-# classification (Mumbai/Delhi/Bangalore/Chennai/Kolkata/Hyderabad =
-# Tier-1 "metro" in insurance vernacular). Bot's pricing uses "metro"
-# as the high-tier loading bucket — keep that as the alias here so a
-# user typing "Mumbai" maps to the same bucket the LLM would store.
-_LOCATION_TIER_MAP: dict[str, str] = {
-    # Metro / Tier-1
-    "mumbai": "metro", "bombay": "metro",
-    "delhi": "metro", "new delhi": "metro",
-    "bangalore": "metro", "bengaluru": "metro",
-    "kolkata": "metro", "calcutta": "metro",
-    "chennai": "metro", "madras": "metro",
-    "hyderabad": "metro",
-    "metro": "metro", "tier 1": "tier1", "tier1": "tier1", "tier-1": "tier1",
-    # Tier-2
-    "pune": "tier2", "ahmedabad": "tier2", "jaipur": "tier2",
-    "lucknow": "tier2", "kanpur": "tier2", "nagpur": "tier2",
-    "indore": "tier2", "thane": "tier2", "bhopal": "tier2",
-    "visakhapatnam": "tier2", "vizag": "tier2",
-    "patna": "tier2", "vadodara": "tier2", "baroda": "tier2",
-    "ghaziabad": "tier2", "ludhiana": "tier2", "agra": "tier2",
-    "nashik": "tier2", "faridabad": "tier2", "meerut": "tier2",
-    "rajkot": "tier2", "varanasi": "tier2", "srinagar": "tier2",
-    "aurangabad": "tier2", "amritsar": "tier2", "navi mumbai": "tier2",
-    "allahabad": "tier2", "prayagraj": "tier2", "ranchi": "tier2",
-    "howrah": "tier2", "coimbatore": "tier2", "jabalpur": "tier2",
-    "gwalior": "tier2", "vijayawada": "tier2", "jodhpur": "tier2",
-    "raipur": "tier2", "kota": "tier2", "chandigarh": "tier2",
-    "guwahati": "tier2", "solapur": "tier2", "hubli": "tier2",
-    "mysore": "tier2", "mysuru": "tier2",
-    "tier 2": "tier2", "tier2": "tier2", "tier-2": "tier2",
-    # Tier-3 buckets (rest)
-    "tier 3": "tier3", "tier3": "tier3", "tier-3": "tier3",
-    "small town": "tier3", "village": "tier3", "rural": "tier3",
-}
-
-
-def _extract_location_tier_from_text(text: str) -> Optional[str]:
-    """Best-effort location_tier from a free-form user reply.
-    Returns "metro" / "tier1" / "tier2" / "tier3" or None.
-    Matches whole tokens / phrases against _LOCATION_TIER_MAP.
-    """
-    if not text:
-        return None
-    s = text.lower()
-    # Longest-key-first so "navi mumbai" beats "mumbai".
-    for key in sorted(_LOCATION_TIER_MAP.keys(), key=len, reverse=True):
-        # Word-boundary match for single-word keys; substring for
-        # multi-word keys (which already have natural boundaries).
-        if " " in key:
-            if key in s:
-                return _LOCATION_TIER_MAP[key]
-        else:
-            if re.search(rf"\b{re.escape(key)}\b", s):
-                return _LOCATION_TIER_MAP[key]
-    return None
-
-
-def _extract_income_band_from_text(text: str) -> Optional[str]:
-    """Best-effort income_band from free-form text.
-    Delegates to needs_finder._parse_income_band so the canonical
-    bucket set (under_5L / 5L-10L / 10L-25L / 25L+) is honored.
-    """
-    if not text:
-        return None
-    try:
-        from backend.needs_finder import _parse_income_band
-    except Exception:
-        return None
-    try:
-        return _parse_income_band(text)
-    except Exception:
-        return None
-
-
-def _parse_user_text_facts(user_text: str) -> Dict[str, Any]:
-    """Run all four identity-fact extractors against user_text. Returns
-    a dict of only the fields that successfully parsed. Used by both
-    the two-fact recall gate (rehydrate_by_name) and the same-turn
-    match-before-merge guard (apply_pending_recall).
-    """
-    if not user_text:
-        return {}
-    out: Dict[str, Any] = {}
-    for fld, fn in (
-        ("age", _extract_age_from_text),
-        ("dependents", _extract_dependents_from_text),
-        ("location_tier", _extract_location_tier_from_text),
-        ("income_band", _extract_income_band_from_text),
-    ):
-        v = fn(user_text)
-        if v not in (None, "", []):
-            out[fld] = v
-    return out
-
 _log = logging.getLogger(__name__)
 
 
@@ -209,35 +51,20 @@ class SessionState:
     awaiting_question_id: Optional[str] = None  # if set, next user message answers this
     free_form_session: bool = False              # user explicitly opted out of fact-find
     last_touched: float = field(default_factory=time.time)
-    # KI-196 (ADR-041) — confirmation-gated profile recall. When a fresh
-    # session captures a name that matches an on-disk profile, the recall
-    # is staged here (NOT auto-merged) and surfaced to the sales_brain as a
-    # one-shot "welcome back" prompt. Affirm → merge stored fields into
-    # `profile`. Negate → discard. Shape:
-    #   {
-    #     "name": "Rohit Sarma",
-    #     "summary": {age, dependents, location_tier, primary_goal, ...},
-    #     "captured_this_turn": {<field>: <value>, ...},  # don't re-extract
-    #     "staged_at": <epoch-seconds>,
-    #   }
-    pending_profile_recall: Optional[Dict[str, Any]] = None
     # KI-224 — most-recent recommendation policy_ids the brain cited on the
-    # last user-visible recommendation/comparison turn. Populated by the
-    # orchestrator after a clean closer reply. Lets the NEXT turn route
+    # last user-visible recommendation/comparison turn. Populated by
+    # single_brain after a clean closer reply. Lets the NEXT turn route
     # follow-ups like "tell me more about #2" without re-retrieving from
     # scratch. Empty list = no active shortlist on this session.
     last_recommendation_ids: list = field(default_factory=list)
     # X7 (admin Recommendation History — conversation_turn column).
-    # Monotonically incremented at the START of every orchestrator.handle_turn
-    # and single_brain.handle_turn call so the policy-event writer can stamp
-    # `turn_idx` on each event dict. Frontend renders this as the
-    # "Conversation turn" column in the admin Recommendation History panel
-    # (previously showed "—" because no caller populated the field).
+    # Monotonically incremented at the START of every single_brain.handle_turn
+    # call so the policy-event writer can stamp `turn_idx` on each event dict.
     turn_idx: int = 0
     # Set True after the first successful single_brain turn; a later
     # SingleBrainError on the same session then emits a graceful retry
     # prompt instead of switching handlers, so the session stays on
-    # single_brain.
+    # single_brain (see ADR-042 retry policy in single_brain._gemini_call).
     single_brain_sticky: bool = False
     # Post-recap pricing & family-history bundle re-ask gate
     # (brain_tools.retrieve_policies):
@@ -248,23 +75,6 @@ class SessionState:
     #     explicitly declines the pricing inputs; bypasses the re-ask.
     pricing_bundle_reasked: bool = False
     pricing_bundle_skipped: bool = False
-    # Bug #25 (2026-05-19) — one-shot guard for returning-user recall.
-    # The old wiring only probed on turn 1, but the fact-find asks the
-    # name in the bot's FIRST reply, so the name lands on turn >=2 and
-    # recall never fired. The probe now runs whenever the name is first
-    # known (any turn); this flag stops it re-staging every subsequent
-    # turn and stops a declined recall from being re-offered.
-    recall_probe_done: bool = False
-    # ADR-042 follow-up #1 (2026-05-27) — two-fact recall gate. When
-    # rehydrate_by_name finds a stored profile under the captured name
-    # but the live session has NO identity-fact match (and user_text
-    # carried no parseable fact either), it sets this flag instead of
-    # staging. The caller (single_brain.py) sees this and DOES NOT set
-    # recall_probe_done=True, so the probe retries on subsequent turns
-    # as more facts come in via save_profile_field. Reset to False by
-    # the caller every retry. Prevents the slug-collision Welcome-Back
-    # leak from ever firing on a bare-name intro.
-    recall_match_deferred: bool = False
 
     def _flush(self) -> None:
         """No-op. Session state lives only in the in-memory dict; the
@@ -299,326 +109,22 @@ _TTL_SECONDS = 60 * 60         # 1h idle → evict from in-memory cache
 
 
 def get_session(session_id: str) -> SessionState:
+    """Return the live in-memory SessionState for `session_id`, creating
+    a fresh blank one on miss. Idle sessions older than _TTL_SECONDS are
+    evicted lazily on every call. Disk is never consulted — see ADR-043.
+    """
     with _lock:
         now = time.time()
-        # Evict idle entries from the hot cache
+        # Evict idle entries from the hot cache.
         to_kill = [k for k, v in _sessions.items() if now - v.last_touched > _TTL_SECONDS]
         for k in to_kill:
             del _sessions[k]
         if session_id in _sessions:
             return _sessions[session_id]
-        # KI-118 — no disk lookup; fresh sessions start blank. Cross-session
-        # rehydration happens via rehydrate_by_name() when the user provides
-        # their name to the fact_find brain.
         _sessions[session_id] = SessionState(session_id=session_id)
         return _sessions[session_id]
 
 
-# Identity-summary fields surfaced in the "are you <name>?" confirm prompt.
-# Enough to let the real owner recognise their own profile, but it is NOT
-# applied to the live session until the user explicitly confirms.
-_RECALL_SUMMARY_FIELDS: tuple[str, ...] = (
-    "age", "dependents", "income_band", "location_tier",
-    "primary_goal", "parents_age_max",
-)
-
-
-def rehydrate_by_name(
-    session: SessionState,
-    name: str,
-    *,
-    user_text: str = "",
-) -> bool:
-    """Cross-session re-entry point — STAGE a name match for confirmation.
-
-    PRIVACY FIX (2026-05-16, audit). Previously this AUTO-MERGED the stored
-    named profile into the live session on the very first turn. Because the
-    lookup key was the user-stated NAME (not the session / no cookie), a
-    second real user on a shared browser/IP — or anyone who simply states a
-    common first name — was silently served a stranger's captured profile
-    and greeted "Welcome back, <name>!". A fresh, no-cookie session must
-    NEVER inherit another session's profile from a weak/shared key.
-
-    PRIVACY HARDENING v4 (2026-05-27, ADR-042 follow-up #1) — TWO-FACT
-    GATE. Even with the explicit confirm gate in apply_pending_recall, a
-    bare-name "Hi I'm Rohit" would still LEAK staged attrs in the
-    Welcome Back prompt (the brain's recall_block was redacted in v1/v2,
-    but the very *existence* of a Welcome Back prompt telegraphs that
-    SOMEONE under this name has used the bot before). The two-fact gate
-    blocks the staging entirely unless at least ONE identity fact —
-    drawn from live `session.profile` (prior-turn captures) OR parsed
-    from `user_text` (same-turn, via _parse_user_text_facts) — MATCHES
-    the stored profile. If a parsed fact CONTRADICTS, staging is also
-    refused (no leak to a different person sharing the name slug). If
-    no identity facts are available yet (bare name), staging is
-    DEFERRED — `session.recall_match_deferred=True` signals the caller
-    to retry on a later turn as more facts come in.
-
-    Safe design (KI-196 / ADR-041, specced via `pending_profile_recall` but
-    previously never wired): a name match is STAGED on
-    `session.pending_profile_recall`, NOT merged. `session.profile` is left
-    untouched, so `is_returning_user` / RULE-4 "Welcome back" does NOT fire
-    on a fresh session. The brain asks the user to confirm ("are you
-    <name>?"); only an explicit affirmation calls `apply_pending_recall(
-    session, confirmed=True)` to merge the stored fields. An explicit deny
-    discards the staged profile.
-
-    Returns:
-        False  — always. The stored profile is NEVER auto-applied here, so
-                 callers must treat False as "do not flag a returning user
-                 / do not greet Welcome back". Whether a match was *staged*
-                 is observable via `session.pending_profile_recall`; the
-                 deferred-retry signal is `session.recall_match_deferred`.
-
-    Failures are logged but never raise — a fresh chat must always proceed.
-    """
-    if not name or not name.strip():
-        return False
-    try:
-        from backend.profile_store import load_profile
-        stored = load_profile(name)
-        if stored is None:
-            # Bug #25 (2026-05-19): a multi-token capture ("Rohit Sar")
-            # slugs to "rohit-sar" and misses the stored first-name file
-            # ("rohit.json"). Fall back to the first name token. Still
-            # privacy-safe — this only STAGES a match; the user must
-            # explicitly confirm the identity summary before any merge.
-            _stripped = (name or "").strip()
-            _first = _stripped.split()[0] if _stripped else ""
-            if _first and _first.lower() != _stripped.lower():
-                stored = load_profile(_first)
-            if stored is None:
-                # No stored profile under this name. Done — no recall
-                # opportunity, no deferral needed.
-                session.recall_match_deferred = False
-                return False
-
-        # ─── TWO-FACT GATE (v4, 2026-05-27) ───────────────────────────
-        # Require at least ONE non-name identity fact to match the
-        # stored profile before staging. Sources for the fact:
-        #   (1) session.profile — already-captured live facts (any
-        #       prior turn of this same session)
-        #   (2) user_text — same-turn parse via _parse_user_text_facts
-        # Any CONTRADICTION fails closed (no stage). No fact available
-        # ⇒ defer (set session.recall_match_deferred=True so the
-        # single_brain caller does NOT mark recall_probe_done, and the
-        # probe retries next turn as more facts come in).
-        same_turn_facts = _parse_user_text_facts(user_text)
-        matched_fact = False
-        contradicted_fact = False
-        for fld in ("age", "dependents", "location_tier", "income_band"):
-            stored_v = getattr(stored, fld, None)
-            if stored_v in (None, "", []):
-                continue
-            # Source 1: prior-turn live capture
-            live_v = getattr(session.profile, fld, None)
-            if live_v not in (None, "", []):
-                if fld == "age":
-                    try:
-                        if int(live_v) == int(stored_v):
-                            matched_fact = True
-                        else:
-                            contradicted_fact = True
-                    except Exception:
-                        pass
-                else:
-                    if str(live_v).strip().lower() == str(stored_v).strip().lower():
-                        matched_fact = True
-                    else:
-                        contradicted_fact = True
-                continue
-            # Source 2: same-turn parse from user_text
-            user_v = same_turn_facts.get(fld)
-            if user_v not in (None, "", []):
-                if fld == "age":
-                    try:
-                        if int(user_v) == int(stored_v):
-                            matched_fact = True
-                        else:
-                            contradicted_fact = True
-                    except Exception:
-                        pass
-                else:
-                    if str(user_v).strip().lower() == str(stored_v).strip().lower():
-                        matched_fact = True
-                    else:
-                        contradicted_fact = True
-
-        if contradicted_fact:
-            # Any contradicting identity fact ⇒ fail-closed. No stage.
-            # Mark probe done so we don't try again — the stored
-            # profile is for a DIFFERENT person sharing this name slug.
-            session.recall_match_deferred = False
-            _log.info(
-                "rehydrate_by_name: identity-fact contradiction for "
-                "name=%r — fail-closed, no stage", name,
-            )
-            return False
-        if not matched_fact:
-            # No fact to confirm a match yet. Defer staging until a
-            # later turn has captured a fact via save_profile_field.
-            session.recall_match_deferred = True
-            session.last_touched = time.time()
-            return False
-
-        # ─── At this point: stored exists AND ≥1 fact matches. Stage. ─
-
-        # Build a non-PII-leaking identity summary so the brain can ask
-        # "are you <name>?" without putting anything on the live profile.
-        summary: Dict[str, Any] = {}
-        for fld in _RECALL_SUMMARY_FIELDS:
-            v = getattr(stored, fld, None)
-            if v not in (None, "", []):
-                summary[fld] = v
-
-        # Snapshot the full stored union so apply_pending_recall can merge
-        # WITHOUT a second disk read (and without the staged copy being
-        # mutated by anything between stage and confirm).
-        staged_fields: Dict[str, Any] = {}
-        for fld in Profile.__dataclass_fields__.keys():
-            v = getattr(stored, fld, None)
-            if v not in (None, "", []):
-                staged_fields[fld] = v
-
-        session.pending_profile_recall = {
-            "name": (getattr(stored, "name", None) or name).strip(),
-            "summary": summary,
-            "stored_fields": staged_fields,
-            "staged_at": time.time(),
-        }
-        session.recall_match_deferred = False
-        session.last_touched = time.time()
-        # Deliberately False: nothing merged, no Welcome-back greeting.
-        return False
-    except Exception as e:
-        _log.warning(
-            "rehydrate_by_name failed (name=%r): %s: %s",
-            name, type(e).__name__, str(e)[:200],
-        )
-        return False
-
-
-def apply_pending_recall(
-    session: SessionState,
-    *,
-    confirmed: bool,
-    user_text: str = "",
-) -> bool:
-    """Resolve a staged cross-session profile recall.
-
-    PRIVACY FIX (2026-05-16). The ONLY path that merges a stored, name-keyed
-    profile into a live session. Called after the user explicitly answers
-    the "are you <name>?" confirm prompt.
-
-    PRIVACY HARDENING (2026-05-27). The brain prompt no longer discloses
-    staged attrs (single_brain.py recall_block). To compensate for the
-    accidental / mistaken "yes" path, we now run a **match-before-merge**
-    contradiction check: if the live profile has captured any identity
-    fact in this conversation that CONTRADICTS the staged recall (e.g.
-    user said age=29 but staged.age=34), we discard the staged recall
-    entirely — no partial merge. Empty live slots (no contradiction
-    possible) are still filled from staged on confirmed=True.
-
-    confirmed=True  — the user affirmed it's them. Stored fields fill any
-                      EMPTY slot on the live profile — UNLESS any live slot
-                      contradicts the staged value (then the whole staged
-                      recall is dropped). Returns True iff a profile was
-                      applied.
-    confirmed=False — the user denied / it isn't them. The staged recall is
-                      discarded. The live session stays blank. Returns False.
-
-    Idempotent: clears `pending_profile_recall` either way. A no-op (returns
-    False) when there is nothing staged.
-    """
-    pending = getattr(session, "pending_profile_recall", None)
-    if not pending:
-        return False
-    # Resolve the staging regardless of outcome.
-    session.pending_profile_recall = None
-    # Bug #25 (2026-05-19) — a confirmed OR denied recall is final for
-    # this session; never auto-re-stage / re-offer it on a later turn.
-    session.recall_probe_done = True
-    if not confirmed:
-        return False
-    stored_fields = pending.get("stored_fields") or {}
-    if not stored_fields:
-        return False
-    # PRIVACY HARDENING (2026-05-27) — match-before-merge guard.
-    # Fields chosen here are decision-critical identity facts where a
-    # mismatch unambiguously means "different person" (vs. e.g.
-    # health_conditions which evolves between visits).
-    _GUARD_FIELDS = (
-        "age", "dependents", "income_band", "location_tier",
-        "primary_goal", "parents_age_max",
-    )
-    for fld in _GUARD_FIELDS:
-        live_v = getattr(session.profile, fld, None)
-        staged_v = stored_fields.get(fld)
-        if live_v in (None, "", []) or staged_v in (None, "", []):
-            continue
-        # Normalise to compare. Int and string forms of age both common.
-        if str(live_v).strip().lower() != str(staged_v).strip().lower():
-            _log.info(
-                "apply_pending_recall: prior-turn contradiction on %s "
-                "(live=%r, staged=%r) — discarding staged recall, "
-                "no merge",
-                fld, live_v, staged_v,
-            )
-            return False
-    # PRIVACY HARDENING v2 (2026-05-27) — same-turn contradiction guard.
-    # _affirm_or_deny + apply_pending_recall fire BEFORE the LLM iteration
-    # that runs save_profile_field, so a user reply like "Yes I'm 35"
-    # against a staged Rohit at age=29 would otherwise slip through the
-    # prior-turn guard (live.<fld>=None at this point) and merge the
-    # wrong profile.
-    #
-    # PRIVACY HARDENING v3 (2026-05-27, ADR-042 follow-up #2): extended
-    # from age-only to all four decision-critical identity facts
-    # (age / dependents / location_tier / income_band) via
-    # _parse_user_text_facts. Mis-parses return None and cost nothing.
-    if user_text:
-        same_turn_facts = _parse_user_text_facts(user_text)
-        for fld, user_v in same_turn_facts.items():
-            staged_v = stored_fields.get(fld)
-            if staged_v in (None, "", []):
-                continue
-            # Normalise. Age is the only numeric; the rest are strings.
-            if fld == "age":
-                try:
-                    staged_norm = int(staged_v)
-                    user_norm = int(user_v)
-                except Exception:
-                    continue
-                if staged_norm != user_norm:
-                    _log.info(
-                        "apply_pending_recall: same-turn age contradiction "
-                        "(user_text age=%d, staged.age=%s) — discarding "
-                        "staged recall, no merge",
-                        user_norm, staged_v,
-                    )
-                    return False
-            else:
-                if str(user_v).strip().lower() != str(staged_v).strip().lower():
-                    _log.info(
-                        "apply_pending_recall: same-turn %s contradiction "
-                        "(user_text=%r, staged=%r) — discarding staged "
-                        "recall, no merge",
-                        fld, user_v, staged_v,
-                    )
-                    return False
-    for fld, new in stored_fields.items():
-        try:
-            if fld not in Profile.__dataclass_fields__:
-                continue
-            cur = getattr(session.profile, fld, None)
-            if cur in (None, "", []) and new not in (None, "", []):
-                setattr(session.profile, fld, new)
-        except Exception:
-            continue
-    session.last_touched = time.time()
-    return True
-
-
 def set_free_form(session_id: str, free_form: bool = True) -> None:
     s = get_session(session_id)
     s.free_form_session = free_form
@@ -630,9 +136,9 @@ def reset_session(session_id: str) -> bool:
     """Delete a session — evict from in-memory cache.
     Returns True if anything was actually deleted.
 
-    KI-020 (2026-05-14) — backs the user-facing "Clear chat / start fresh" toggle.
-    KI-118 (2026-05-15) — no disk file to remove anymore; in-memory eviction
-    is the only side effect. Returns True iff the session id was live.
+    KI-020 (2026-05-14) — backs the user-facing "Clear chat / start fresh"
+    toggle. KI-118 (2026-05-15) removed disk persistence; in-memory
+    eviction is the only side effect.
     """
     with _lock:
         if session_id in _sessions:
@@ -642,17 +148,13 @@ def reset_session(session_id: str) -> bool:
 
 
 def clear_session(session_id: str) -> bool:
-    """KI-196 (ADR-041) — Wipe in-memory state for one session_id WITHOUT
-    touching any on-disk profile JSON under `40-data/profiles/`.
-
-    Semantically identical to `reset_session` today (both just evict the
-    in-memory entry; the disk profile has always been independent and lives
-    by persona_id / name slug, not session_id). Kept as a distinct symbol so
-    the call-site intent at `POST /api/session/clear` is self-documenting and
-    so future divergence (e.g. partial-state wipes) doesn't require touching
-    the legacy KI-020 caller.
+    """Wipe in-memory state for one session_id.
 
-    Returns True iff a live in-memory session was evicted.
+    Semantically identical to `reset_session` (both just evict the
+    in-memory entry). Kept as a distinct symbol so the call-site intent
+    at `POST /api/session/clear` is self-documenting and so future
+    divergence (e.g. partial-state wipes) doesn't require touching the
+    legacy KI-020 caller.
     """
     with _lock:
         if session_id in _sessions:
@@ -662,8 +164,9 @@ def clear_session(session_id: str) -> bool:
 
 
 def purge_old_files() -> int:
-    """KI-118 (2026-05-15) — no-op. Disk persistence was removed; there are
-    no files to purge. Kept as a stub so any existing scheduled-task caller
-    (cron / startup hook) doesn't crash on attribute miss.
+    """No-op. Disk persistence was removed in KI-118 (2026-05-15) and
+    cross-session profile recall was removed in ADR-043 (2026-05-27).
+    Kept as a stub so any existing scheduled-task caller (cron / startup
+    hook) doesn't crash on attribute miss.
     """
     return 0

backend/single_brain.py

@@ -737,63 +737,15 @@ def _build_contents(
     return out
 
 
-# WHOLE-WORD tokens (matched against the tokenised message, NOT as
-# substrings — "no" must not match "k(no)ws", "ya" must not match "Ma(ya)").
-_RECALL_DENY_TOKENS = {
-    "no", "nope", "nah", "naah", "nahi", "wrong", "never", "neither",
-    "nopes", "nahin",
-}
-_RECALL_AFFIRM_TOKENS = {
-    "yes", "yeah", "yep", "yup", "ya", "yaa", "yaah", "yess", "haan",
-    "han", "haa", "correct", "right", "sahi", "bilkul", "sure", "indeed",
-    "absolutely", "exactly", "true", "yup",
-}
-# Multi-word phrases — safe to match as substrings.
-_RECALL_DENY_PHRASES = (
-    "not me", "isn't me", "isnt me", "not the same", "start fresh",
-    "start over", "different person", "new user", "someone else",
-    "not rohit", "first time", "never been", "fresh start", "not him",
-    "not her", "i'm new", "im new", "not that person", "don't know",
-    "dont know", "different one",
-)
-_RECALL_AFFIRM_PHRASES = (
-    "that's me", "thats me", "that is me", "it's me", "its me", "i am",
-    "pick up", "go ahead", "that's right", "thats right", "that's correct",
-    "thats correct", "yes please", "continue where", "same person",
-    "carry on", "of course",
-)
-_RECALL_TOKEN_RE = __import__("re").compile(r"[a-z']+")
-
-
-def _affirm_or_deny(text: str):
-    """Conservative yes/no for the returning-user confirm gate.
-
-    Returns True (affirm), False (deny), or None (ambiguous → re-ask).
-    Deny wins ties: privacy is fail-closed — an ambiguous "no, but…" must
-    NEVER merge a stranger's stored profile (ADR-041 / KI-196). Short
-    tokens are matched whole-word (tokenised), not as substrings, so
-    "who knows" / "i don't know" / "now" are NOT read as "no".
-    """
-    t = (text or "").strip().lower()
-    if not t:
-        return None
-    toks = set(_RECALL_TOKEN_RE.findall(t))
-    deny = bool(toks & _RECALL_DENY_TOKENS) or any(
-        p in t for p in _RECALL_DENY_PHRASES
-    )
-    if deny:
-        return False
-    affirm = bool(toks & _RECALL_AFFIRM_TOKENS) or any(
-        p in t for p in _RECALL_AFFIRM_PHRASES
-    )
-    if affirm:
-        return True
-    return None
+# Returning-user recall machinery was removed in ADR-043 (2026-05-27).
+# Sessions are in-memory only; closing the tab discards the profile.
+# Bug #26 STATE-RECOVERY-from-chat_history (an in-session container-restart
+# resilience path) is the only profile-rebuild mechanism that remains — it
+# is NOT cross-session and never reads disk.
 
 
 def _system_instruction(
     profile, is_returning_user: bool = False, shortlist_block: str = "",
-    pending_recall: "Optional[dict]" = None, recall_applied: bool = False,
     reconstruct_from_history: bool = False,
 ) -> dict:
     """Bake the profile snapshot into the system prompt so each turn the
@@ -831,72 +783,13 @@ def _system_instruction(
                 "say 'Welcome back'):\n"
                 + json.dumps(snapshot, ensure_ascii=False, sort_keys=True)
             )
-    recall_block = ""
-    if pending_recall:
-        _nm = (pending_recall.get("name") or "there").strip()
-        # PRIVACY HARDENING (2026-05-27). Previously this prompt echoed the
-        # staged profile's age / dependents / location_tier / primary_goal
-        # into the user-visible "are you the same <name> (age 34, metro,
-        # kids, first_buy)?" question. That disclosed a prior visitor's
-        # identity facts to ANY stranger who happened to share the name
-        # slug — the recall key is name-only, so two different Rohits
-        # collide on rohit.json. The leak is independent of the merge
-        # gate (apply_pending_recall) because the disclosure happened in
-        # the prompt itself before any user answer.
-        #
-        # New design: do NOT disclose stored attrs. Ask the user to
-        # RE-STATE one identifying fact (their age). On the next turn,
-        # session_state.apply_pending_recall runs a match-before-merge
-        # contradiction check against whatever the user just saved via
-        # save_profile_field — a wrong "yes" plus a contradicting age
-        # discards the staged recall, so a stranger can't inherit prior
-        # attrs even by mis-clicking "yes".
-        recall_block = (
-            "\n\n═══════════════════════════════════\n"
-            "RETURNING-USER CHECK — HIGHEST PRIORITY THIS TURN "
-            "(overrides RULE 1 / fact-find for this one turn)\n"
-            "═══════════════════════════════════\n"
-            f"A stored profile may exist under the name the user just "
-            f"gave (\"{_nm}\"). DO NOT disclose any stored attribute "
-            "(age, dependents, location, goal, conditions, etc.) in your "
-            "reply — disclosing them to an unconfirmed identity is a "
-            "privacy leak. Stay neutral.\n"
-            "Your ENTIRE reply this turn MUST be ONLY the confirmation "
-            "question below. Do NOT call any tool, do NOT save_profile_field, "
-            "do NOT run the 7-question fact-find, do NOT recommend:\n"
-            f"  \"Welcome back — have we spoken before? If yes, please "
-            f"share your age so I can pull up the right profile. If not, "
-            f"no problem — just say so and we'll start fresh.\"\n"
-            "Then wait for their answer on the NEXT turn. If they share "
-            "an age (or other fact), save_profile_field captures it and "
-            "the system runs a match-before-merge check against the "
-            "staged recall — you never merge anything yourself."
-        )
-    restored_block = ""
-    if recall_applied:
-        _rs = json.dumps(snapshot, ensure_ascii=False, sort_keys=True)
-        restored_block = (
-            "\n\n═══════════════════════════════════\n"
-            "RETURNING USER CONFIRMED — PROFILE RESTORED "
-            "(HIGHEST PRIORITY THIS TURN)\n"
-            "═══════════════════════════════════\n"
-            "The user just confirmed they are the SAME returning person. "
-            "Their saved profile is RESTORED and FINAL for every slot "
-            "present here:\n" + _rs + "\n"
-            "Do NOT re-ask, re-confirm, re-verify or 'just double-check' "
-            "ANY slot present above — name, age, dependents, city/location, "
-            "income band, primary goal, health / pre-existing conditions, "
-            "sum insured, existing cover, budget. Re-asking a RESTORED slot "
-            "is a hard error: the entire point of recall is that the user "
-            "does NOT repeat themselves.\n"
-            "Your reply this turn: (1) ONE warm 'welcome back' line, then "
-            "(2) resume exactly where a returning user continues — if the "
-            "RULE 2.5 pricing inputs (sum insured / premium budget / co-pay "
-            "/ smoker / family medical history) are NOT yet captured, ask "
-            "ONLY those via the single RULE 2.5 prompt; otherwise go "
-            "straight to retrieve_policies + recommendations. Ask ONLY for "
-            "a slot that is genuinely ABSENT above — never one present."
-        )
+    # Cross-session "Welcome Back" / "Profile Restored" blocks were
+    # removed in ADR-043 (2026-05-27). Sessions are in-memory only —
+    # closing the tab discards the profile. Only the in-session
+    # STATE-RECOVERY-MODE block below survives, because it never
+    # touches disk (it rebuilds the live profile from the chat_history
+    # the browser still carries when the server's session memory was
+    # evicted mid-conversation).
     reconstruct_block = ""
     if reconstruct_from_history:
         reconstruct_block = (
@@ -920,8 +813,8 @@ def _system_instruction(
             "recommendations. The user must never perceive any loss."
         )
     text = (
-        SYSTEM_PROMPT + extra + recall_block + reconstruct_block
-        + restored_block + (shortlist_block or "")
+        SYSTEM_PROMPT + extra + reconstruct_block
+        + (shortlist_block or "")
     )
     return {"parts": [{"text": text}]}
 
@@ -1935,99 +1828,14 @@ async def handle_turn(
     model = _resolve_model()
     language = _detect_language(user_text)
 
-    # KI-255 — detect "returning user" so RULE 4 (Welcome Back greeting)
-    # only fires when the profile was actually loaded from a prior session.
-    # Signal: session.turn_idx == 1 (first turn of this session_id) AND the
-    # profile already has a captured slot (hydrated from prior persistence).
-    # turn_idx > 1 ⇒ slots filled by save_profile_field within THIS
-    # conversation — not a returning user.
     _current_turn = int(getattr(session, "turn_idx", 1) or 1)
 
-    # ── Returning-user recall (ADR-041 / KI-196), wired into single_brain
-    # 2026-05-19. Previously ORPHANED by the orchestrator→single-LLM
-    # rewrite: extract_potential_name / try_recall_by_name /
-    # apply_pending_recall existed and were unit-tested, but NOTHING on the
-    # live path called them — so a same-name revisit ("Hi, I'm Rohit") was
-    # never recognised and the "are you the same Rohit?" prompt never fired.
-    # Privacy-safe by construction: a name match is only STAGED on
-    # session.pending_profile_recall (never auto-merged); only an explicit
-    # "yes" merges the stored slots, an explicit "no" discards, anything
-    # ambiguous leaves it staged so the LLM re-asks the confirm once.
-    _did_recall_this_turn = False
-    try:
-        from backend.profile_persistence import (
-            extract_potential_name,
-            try_recall_by_name,
-        )
-        from backend.session_state import apply_pending_recall
-
-        _pending_recall = getattr(session, "pending_profile_recall", None)
-        if _pending_recall:
-            _ans = _affirm_or_deny(user_text)
-            if _ans is True:
-                # 2026-05-27 — user_text plumbed in so the same-turn age
-                # contradiction guard inside apply_pending_recall can
-                # discard a wrong-person "Yes I'm 35" reply before merging.
-                _did_recall_this_turn = bool(
-                    apply_pending_recall(
-                        session, confirmed=True, user_text=user_text,
-                    )
-                )
-                _pending_recall = None
-            elif _ans is False:
-                apply_pending_recall(
-                    session, confirmed=False, user_text=user_text,
-                )
-                _pending_recall = None
-            # ambiguous → leave staged; the confirm block is re-injected
-            # below and the LLM re-asks the "are you <name>?" question.
-        elif not getattr(session, "recall_probe_done", False):
-            # Bug #25 (2026-05-19) — recall must fire whenever the user's
-            # NAME first becomes known, NOT only on turn 1. The fact-find
-            # asks for the name in the bot's FIRST reply, so the user
-            # supplies it on turn >=2; the old `_current_turn == 1` gate
-            # skipped recall for the normal flow entirely, so a returning
-            # user was never recognised. The LLM reliably persists the
-            # name via save_profile_field, so `session.profile.name`
-            # (captured on a prior turn) is the robust trigger; we ALSO
-            # keep the free-text sniff for an explicit "I'm X" stated on
-            # the very first message (before save_profile_field has run).
-            _nm = (
-                (getattr(session.profile, "name", None) or "").strip()
-                or (extract_potential_name(user_text or "") or "")
-            )
-            if _nm:
-                # Stages session.pending_profile_recall iff a stored
-                # profile for this name exists AND the two-fact gate
-                # (ADR-042 follow-up #1) is satisfied — i.e., at least
-                # one identity fact (age / dependents / location /
-                # income) MATCHES between stored and the live/parsed
-                # user state. No match yet ⇒ session.recall_match_
-                # deferred=True and we DON'T flip recall_probe_done so
-                # the probe retries next turn when more facts come in.
-                # Still privacy-safe: STAGE only; explicit confirm merges.
-                try_recall_by_name(session, _nm, user_text=user_text)
-                _deferred = bool(
-                    getattr(session, "recall_match_deferred", False)
-                )
-                if not _deferred:
-                    # Probe was conclusive (staged / contradicted / no
-                    # stored profile under this name). Mark done — name
-                    # won't change, no point re-probing.
-                    session.recall_probe_done = True
-                # Else: leave recall_probe_done as-is (False) so the
-                # next turn's gate re-enters this branch after the LLM
-                # has captured another identity fact via
-                # save_profile_field.
-                _pending_recall = getattr(
-                    session, "pending_profile_recall", None
-                )
-    except Exception as _re:  # noqa: BLE001 — recall must never break a turn
-        _log.warning(
-            "returning-user recall wiring failed: %s: %s",
-            type(_re).__name__, str(_re)[:200],
-        )
-        _pending_recall = getattr(session, "pending_profile_recall", None)
+    # Cross-session returning-user recall was REMOVED in ADR-043
+    # (2026-05-27). Sessions are in-memory only — closing the tab
+    # discards the profile, no on-disk lookup happens. `is_returning_user`
+    # remains a tracked flag but it is always False now (kept so
+    # downstream code that may inspect it doesn't break).
+    is_returning_user = False
 
     _has_prior_profile = any(
         getattr(session.profile, fld, None) not in (None, "", [])
@@ -2036,7 +1844,6 @@ async def handle_turn(
             "income_band", "primary_goal", "health_conditions",
         )
     )
-    is_returning_user = (_current_turn == 1) and _has_prior_profile
 
     # Bug #26 (2026-05-19) — mid-conversation profile loss. Sessions are
     # in-memory only (session_state._TTL_SECONDS = 1h; KI-118 removed disk
@@ -2049,10 +1856,12 @@ async def handle_turn(
     # already-stated facts from chat_history instead of resetting. Guard:
     # >=2 history messages ⇒ this is NOT the genuine first turn, so a
     # blank profile means state was lost, not "fresh user".
+    #
+    # NOTE: this is an IN-SESSION recovery path. It rebuilds the live
+    # profile from the chat_history the BROWSER still carries — it never
+    # reads from disk. Compatible with ADR-043's no-cross-session model.
     _reconstruct_from_history = (
         (not _has_prior_profile)
-        and not is_returning_user
-        and not _pending_recall
         and bool(chat_history)
         and len([m for m in (chat_history or [])
                  if (m or {}).get("role") == "user"]) >= 1
@@ -2102,8 +1911,6 @@ async def handle_turn(
         session.profile,
         is_returning_user=is_returning_user,
         shortlist_block=_shortlist_block,
-        pending_recall=_pending_recall,
-        recall_applied=_did_recall_this_turn,
         reconstruct_from_history=_reconstruct_from_history,
     )
 
@@ -2583,26 +2390,10 @@ async def handle_turn(
             "the insurer before relying on it."
         )
 
-    # Bug #25 WRITE-SIDE (2026-05-19) — persist the named profile so a
-    # returning user can actually be recalled. profile_persistence.
-    # auto_persist_session was ORPHANED by the orchestrator→single-LLM
-    # rewrite (same class as the recall LOOKUP helpers + get_policy_facts
-    # + silent-TTS): nothing on the chat path ever called it, so a user
-    # who completed fact-find PURELY BY CHAT was never saved to the named
-    # store and recall had nothing to find — save_profile() only ran from
-    # the POST /api/profile builder UI. Persisting at end-of-turn (after
-    # all save_profile_field tool calls + recall handling have run) closes
-    # the loop. No-ops without a profile.name; swallows all errors so a
-    # stuck disk / Chroma hiccup can never block the chat reply.
-    try:
-        from backend.profile_persistence import auto_persist_session
-
-        await auto_persist_session(session)
-    except Exception as _pe:  # noqa: BLE001 — persistence must NEVER break a turn
-        _log.warning(
-            "auto_persist_session wiring failed: %s: %s",
-            type(_pe).__name__, str(_pe)[:200],
-        )
+    # End-of-turn disk persistence removed in ADR-043 (2026-05-27). The
+    # profile lives only in the in-memory SessionState for the duration
+    # of this session (1 h idle TTL), then evicts. No on-disk JSON, no
+    # Chroma profile chunk, no cross-session recall.
 
     return TurnResult(
         reply_text=reply_text,
@@ -2618,7 +2409,7 @@ async def handle_turn(
         blocked=False,
         profile_updates=profile_updates,
         followup_policy_id=followup_policy_id,
-        returning_user_recalled=_did_recall_this_turn,
+        returning_user_recalled=False,
     )
 
 

frontend/src/lib/api.ts

@@ -565,32 +565,9 @@ export async function getPredictedPremiumBand(
   return resp.json();
 }
 
-// KI-Z7 (2026-05-15) — Feature B. POST /api/profile/recall-by-name.
-// Asks the backend to look up a stored named-profile and hydrate the live
-// session_id with it. The chat path runs the same recall server-side on
-// turn 1, so this client helper is only needed for non-chat triggers (e.g.
-// the user types their name into the profile builder AFTER turn 1).
-export type RecallByNameResponse = {
-  found: boolean;
-  profile: Record<string, unknown> | null;
-  predicted_band:
-    | { min_inr: number; median_inr: number; max_inr: number; sample_size: number; assumed: boolean }
-    | null;
-  session_id: string;
-};
-
-export async function postProfileRecallByName(args: {
-  name: string;
-  session_id: string;
-}): Promise<RecallByNameResponse> {
-  const resp = await fetch(`${BACKEND_URL}/api/profile/recall-by-name`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ name: args.name, session_id: args.session_id }),
-  });
-  if (!resp.ok) throw new Error(`profile recall failed: ${resp.status}`);
-  return resp.json();
-}
+// /api/profile/recall-by-name + postProfileRecallByName were REMOVED in
+// ADR-043 (2026-05-27). Cross-session profile recall no longer exists —
+// closing the tab discards the session profile entirely.
 
 export async function postProfileUpdate(req: UserProfile & { session_id: string }): Promise<ProfileCompletenessResponse> {
   const resp = await fetch(`${BACKEND_URL}/api/profile`, {

tests/test_bug2526_recall_and_reconstruct.py

@@ -1,224 +0,0 @@
-"""Regression tests for the live bugs #25 and #26 (2026-05-19).
-
-#25 — returning user NEVER recognised: the recall probe was gated to
-`_current_turn == 1`, but the fact-find asks for the name in the bot's
-FIRST reply, so the name lands on turn >=2 and the probe was skipped
-entirely. Compounded by (b) `extract_potential_name` only matching an
-"I'm X / my name is X" preamble (a bare "rohit sar" → None) and (c) a
-multi-token name slugging to "rohit-sar", missing the stored
-"rohit.json". The fix: probe whenever the LLM-captured
-`session.profile.name` is first known (any turn), with a first-name
-slug fallback, one-shot guarded — STILL privacy-safe (STAGE + explicit
-confirm; no auto-merge).
-
-#26 — profile lost mid-conversation: in-memory sessions
-(_TTL_SECONDS=1h, KI-118 removed disk persistence) get evicted on an HF
-container restart / idle, so get_session() returns a BLANK session and
-the bot says "I seem to have lost some of your profile information.
-What's your name?". Fix (user-chosen): when the live profile is blank
-but the client still carries chat_history, inject STATE-RECOVERY MODE so
-the model silently re-captures the facts from history and continues —
-never re-asking the name / never admitting a loss.
-
-Each test is written so it FAILS on the pre-fix code (the exact gap
-that let the bug ship) and passes only with the fix.
-"""
-import asyncio
-import os
-import random
-import string
-import unittest
-import uuid
-from unittest import mock
-
-from backend import single_brain
-from backend.session_state import SessionState, apply_pending_recall
-from backend.profile_persistence import try_recall_by_name  # noqa: F401
-from backend.profile_store import save_profile, _normalise_name, _PROFILES_DIR
-from backend.needs_finder import Profile
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _text_payload(text):
-    return {"candidates": [{"content": {"parts": [{"text": text}]}}]}
-
-
-class _FirstNameStoredFixture(unittest.TestCase):
-    """Stores a profile under a SINGLE-token name (like the real
-    40-data/profiles/rohit.json) so a later two-token capture
-    ("Rohit Sar") must use the first-name slug fallback to resolve it."""
-
-    def setUp(self):
-        self.first = "Firstonly" + "".join(
-            random.choices(string.ascii_lowercase, k=7))
-        self.full = f"{self.first} Lastname"           # what the user types
-        self.slug = _normalise_name(self.first)
-        p = Profile()
-        p.name = self.first
-        p.age = 41
-        p.dependents = "self+spouse+1 kid"
-        p.location_tier = "metro"
-        p.income_band = "10L-25L"
-        p.primary_goal = "first_buy"
-        p.health_conditions = ["none"]
-        self.assertTrue(save_profile(self.first, p),
-                        "fixture save_profile failed")
-        self._env = mock.patch.dict(
-            os.environ, {"GOOGLE_API_KEY": "test-key"})
-        self._env.start()
-        self.sys_prompts = []
-        self.si_kwargs = []
-
-        async def _fake_gemini(*_a, **_k):
-            self.sys_prompts.append(
-                (_k.get("system_instruction") or {})
-                .get("parts", [{}])[0].get("text", ""))
-            return _text_payload("ok")
-
-        self._gp = mock.patch.object(
-            single_brain, "_gemini_call", _fake_gemini)
-        self._gp.start()
-
-        # Spy on _system_instruction WITHOUT changing behaviour, to assert
-        # the #26 reconstruct flag wiring end-to-end.
-        _real_si = single_brain._system_instruction
-
-        def _spy_si(*a, **k):
-            self.si_kwargs.append(k)
-            return _real_si(*a, **k)
-
-        self._sp = mock.patch.object(
-            single_brain, "_system_instruction", _spy_si)
-        self._sp.start()
-
-    def tearDown(self):
-        self._sp.stop()
-        self._gp.stop()
-        self._env.stop()
-        try:
-            import json
-            for fp in _PROFILES_DIR.glob("*.json"):
-                # Bug-#45 test hygiene: handle_turn now auto-persists ANY
-                # captured name, so the hard-coded "unknown name" used by
-                # test_unknown_name_no_false_recall_later_turn leaks a
-                # zzqxnobody*.json. Clean it (and this fixture's own files)
-                # so a re-run starts from a true no-stored-profile state.
-                if fp.stem.startswith("zzqxnobody"):
-                    fp.unlink(missing_ok=True)
-                    continue
-                try:
-                    d = json.loads(fp.read_text())
-                except Exception:
-                    continue
-                if d.get("name_slug") == self.slug or \
-                   (d.get("profile") or {}).get("name") == self.first:
-                    fp.unlink(missing_ok=True)
-        except Exception:
-            pass
-
-
-class TestBug25RecallAfterTurn1(_FirstNameStoredFixture):
-    def test_name_captured_on_later_turn_stages_recall(self):
-        """The exact #25 flow: turn 1 has no name; the LLM captures the
-        name (save_profile_field) so by a later turn session.profile.name
-        is a TWO-token string. Old code: `elif _current_turn == 1`
-        skipped the probe AND the slug missed the stored file → recall
-        NEVER fired. Fixed: staged + confirm prompt injected."""
-        sess = SessionState(session_id=f"b25_{uuid.uuid4().hex[:8]}")
-        # Turn 1 — user states intent only, NO name.
-        _run(single_brain.handle_turn(sess, "I want a health policy"))
-        self.assertIsNone(getattr(sess, "pending_profile_recall", None),
-                           "no name yet → must not stage on turn 1")
-        # The LLM captured the name via save_profile_field on turn 2;
-        # replicate that exact server state (two-token name).
-        sess.profile.name = self.full
-        # A normal later fact-find turn (turn 3) — bare answer, NOT a
-        # name preamble, NOT turn 1: the precise pre-fix dead zone.
-        _run(single_brain.handle_turn(sess, "no pre-existing conditions"))
-        pr = getattr(sess, "pending_profile_recall", None)
-        self.assertTrue(
-            pr, "#25: recall not staged when name known after turn 1")
-        self.assertEqual(pr["name"], self.first,
-                         "#25: first-name slug fallback did not resolve "
-                         "the stored profile")
-        self.assertIn("RETURNING-USER CHECK", self.sys_prompts[-1],
-                      "#25: confirm block not injected")
-        self.assertTrue(getattr(sess, "recall_probe_done", False),
-                        "#25: one-shot guard not set")
-
-    def test_explicit_yes_then_merges(self):
-        sess = SessionState(session_id=f"b25y_{uuid.uuid4().hex[:8]}")
-        sess.profile.name = self.full
-        _run(single_brain.handle_turn(sess, "just me"))
-        self.assertTrue(sess.pending_profile_recall)
-        r2 = _run(single_brain.handle_turn(sess, "yes, that's me"))
-        self.assertTrue(r2.returning_user_recalled)
-        self.assertEqual(sess.profile.age, 41,
-                         "stored profile not merged on explicit yes")
-
-    def test_declined_recall_not_reoffered(self):
-        sess = SessionState(session_id=f"b25n_{uuid.uuid4().hex[:8]}")
-        sess.profile.name = self.full
-        _run(single_brain.handle_turn(sess, "just me"))
-        self.assertTrue(sess.pending_profile_recall)
-        apply_pending_recall(sess, confirmed=False)
-        self.assertTrue(sess.recall_probe_done)
-        # A later turn must NOT re-stage the declined recall.
-        _run(single_brain.handle_turn(sess, "income 25L+"))
-        self.assertIsNone(getattr(sess, "pending_profile_recall", None),
-                          "#25: declined recall was re-offered")
-
-    def test_unknown_name_no_false_recall_later_turn(self):
-        sess = SessionState(session_id=f"b25u_{uuid.uuid4().hex[:8]}")
-        sess.profile.name = "Zzqxnobodyhasthis Lastname"
-        _run(single_brain.handle_turn(sess, "no pre-existing conditions"))
-        self.assertIsNone(getattr(sess, "pending_profile_recall", None))
-        self.assertNotIn("RETURNING-USER CHECK", self.sys_prompts[-1])
-
-
-class TestBug26ReconstructFromHistory(_FirstNameStoredFixture):
-    def _hist(self):
-        return [
-            {"role": "user", "content": "I want a health policy"},
-            {"role": "assistant", "content": "Sure — your name and age?"},
-            {"role": "user", "content": "Rohit, 29, Bangalore"},
-            {"role": "assistant", "content": "Thanks Rohit. Income band?"},
-        ]
-
-    def test_blank_session_with_history_triggers_reconstruction(self):
-        """Evicted/blank session BUT the client still carries the
-        conversation → STATE-RECOVERY MODE, not "What's your name?"."""
-        sess = SessionState(session_id=f"b26_{uuid.uuid4().hex[:8]}")
-        _run(single_brain.handle_turn(
-            sess, "income 25L+", chat_history=self._hist()))
-        self.assertTrue(
-            self.si_kwargs[-1].get("reconstruct_from_history"),
-            "#26: reconstruction not triggered for blank+history")
-        self.assertIn("STATE-RECOVERY MODE", self.sys_prompts[-1])
-        self.assertNotIn("lost some of your profile",
-                         self.sys_prompts[-1].lower())
-
-    def test_genuine_first_turn_no_reconstruction(self):
-        sess = SessionState(session_id=f"b26f_{uuid.uuid4().hex[:8]}")
-        _run(single_brain.handle_turn(sess, "I want a health policy"))
-        self.assertFalse(
-            self.si_kwargs[-1].get("reconstruct_from_history"),
-            "#26: false recovery on a genuine first turn")
-        self.assertNotIn("STATE-RECOVERY MODE", self.sys_prompts[-1])
-
-    def test_populated_session_no_reconstruction(self):
-        sess = SessionState(session_id=f"b26p_{uuid.uuid4().hex[:8]}")
-        sess.profile.name = "Asha"
-        sess.profile.age = 30
-        _run(single_brain.handle_turn(
-            sess, "income 25L+", chat_history=self._hist()))
-        self.assertFalse(
-            self.si_kwargs[-1].get("reconstruct_from_history"),
-            "#26: reconstruction wrongly fired on a populated session")
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_bug45_chat_profile_persistence.py

@@ -1,129 +0,0 @@
-"""Regression test for bug #45 (2026-05-19) — the REAL cause of the
-recurring "returning user not recognised" complaint.
-
-`profile_persistence.auto_persist_session()` (saves the named profile to
-disk + Chroma) was ORPHANED by the orchestrator→single-LLM rewrite:
-nothing on the chat path called it, so a user who completed fact-find
-PURELY BY CHAT was never persisted to the named store (save_profile()
-only ran from the POST /api/profile builder UI). The recall LOOKUP fix
-(#25) was correct but its verification used a pre-existing rohit.json,
-masking this write-side gap. A live audit with a brand-new chat-only
-"Auditkumar Verma" then a fresh same-name session got NO recall —
-because nothing wrote auditkumar*.json.
-
-Fix: single_brain.handle_turn now awaits auto_persist_session(session)
-at end-of-turn. These tests pin the write-side end-to-end and FAIL on
-the pre-fix code.
-"""
-import asyncio
-import os
-import random
-import string
-import unittest
-from unittest import mock
-
-from backend import single_brain
-from backend.session_state import SessionState
-from backend.profile_store import load_profile, _normalise_name, _PROFILES_DIR
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _text_payload(text):
-    return {"candidates": [{"content": {"parts": [{"text": text}]}}]}
-
-
-class TestBug45ChatProfilePersistence(unittest.TestCase):
-    def setUp(self):
-        self.first = "Persisttester" + "".join(
-            random.choices(string.ascii_lowercase, k=7))
-        self.slug = _normalise_name(self.first)
-        self._env = mock.patch.dict(
-            os.environ, {"GOOGLE_API_KEY": "test-key"})
-        self._env.start()
-
-        async def _fake_gemini(*_a, **_k):
-            return _text_payload("Thanks — noted.")
-
-        self._gp = mock.patch.object(
-            single_brain, "_gemini_call", _fake_gemini)
-        self._gp.start()
-
-    def tearDown(self):
-        self._gp.stop()
-        self._env.stop()
-        try:
-            import json
-            for fp in _PROFILES_DIR.glob("*.json"):
-                try:
-                    d = json.loads(fp.read_text())
-                except Exception:
-                    continue
-                if d.get("name_slug") == self.slug or \
-                   (d.get("profile") or {}).get("name") == self.first:
-                    fp.unlink(missing_ok=True)
-        except Exception:
-            pass
-
-    def _completed_profile_session(self):
-        """A session whose profile the LLM has fully captured by chat
-        (exactly the end state of a normal conversational fact-find)."""
-        s = SessionState(session_id=f"b45_{self.first.lower()}")
-        p = s.profile
-        p.name = self.first
-        p.age = 38
-        p.dependents = "self+spouse+1 kid"
-        p.location_tier = "metro"
-        p.income_band = "25L+"
-        p.primary_goal = "first_buy"
-        p.health_conditions = ["none"]
-        return s
-
-    def test_chat_turn_persists_named_profile_to_disk(self):
-        """The exact #45 gap: a chat-only completed profile must be
-        written to the named store at end-of-turn so a return visit can
-        recall it. Pre-fix: auto_persist_session was never called →
-        load_profile() is None."""
-        self.assertIsNone(load_profile(self.first),
-                          "fixture leaked a pre-existing profile")
-        sess = self._completed_profile_session()
-        _run(single_brain.handle_turn(sess, "yes that's all correct"))
-        stored = load_profile(self.first)
-        self.assertIsNotNone(
-            stored,
-            "#45: chat fact-find did NOT persist the named profile "
-            "(auto_persist_session still orphaned)")
-        self.assertEqual(getattr(stored, "age", None), 38,
-                         "#45: persisted profile is missing captured slots")
-
-    def test_anonymous_turn_does_not_persist(self):
-        """No name → never write to disk (KI-118 privacy gate intact)."""
-        s = SessionState(session_id="b45_anon")
-        s.profile.age = 30
-        _run(single_brain.handle_turn(s, "I want a health policy"))
-        # nothing with our unique slug should have been created
-        self.assertIsNone(load_profile(self.first))
-
-    def test_persist_then_fresh_session_recall_fires(self):
-        """End-to-end: chat-only persist (#45 write) THEN a brand-new
-        session giving the same name → recall stages (#25 lookup). This
-        is the real-user flow the prior pre-seeded verification skipped."""
-        sess = self._completed_profile_session()
-        _run(single_brain.handle_turn(sess, "yes that's all correct"))
-        self.assertIsNotNone(load_profile(self.first), "precondition: "
-                             "profile must be persisted by the chat turn")
-        # Brand-new session; user states the same name mid-fact-find.
-        s2 = SessionState(session_id="b45_return")
-        s2.profile.name = f"{self.first} Kumar"   # two-token, like real
-        _run(single_brain.handle_turn(s2, "no pre-existing conditions"))
-        pr = getattr(s2, "pending_profile_recall", None)
-        self.assertTrue(
-            pr, "#45+#25: returning user not recalled even though the "
-            "chat-only profile was persisted")
-        self.assertEqual(pr["name"], self.first)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_profile_rag_isolation.py

@@ -1,665 +0,0 @@
-"""Regression tests for KI-102 / KI-112 / KI-117 / KI-118 — profile-RAG safety.
-
-KI-118 (2026-05-15) rewrites the threat model. Profile chunks are NO LONGER
-keyed by session_id; they are keyed by `name_slug` (canonical user name)
-and only NAMED users ever get embedded. Anonymous chats never write to
-Chroma — the corruption surface that the session_id keying introduced
-(the legacy `profile_anonymous` dangling row that poisoned every query
-with a `where` clause referencing session_id) is now structurally
-unreachable.
-
-The remaining safety guarantees these tests pin:
-
-  KI-102 / KI-118 — main retrieval cosine pass MUST NOT return profile
-                    chunks (`where={'doc_type': {'$ne': 'profile'}}`).
-                    Profile chunks are exclusively surfaced via the
-                    explicit per-name lookup
-                    `collection.get(ids=[f'profile_{name_slug}'])`.
-
-  KI-118.a — upsert_profile_chunk stamps `name_slug` into Chroma metadata.
-  KI-118.b — retrieve()'s per-name lookup gates on metadata.name_slug ==
-             caller's slug (triple-check), so cross-name leakage is blocked.
-
-  KI-112 — input guards: empty/None name_slug refused; mis-shaped embeddings
-           refused. These remain in place.
-
-  KI-107 — retrieve() with a missing/non-existent profile must NEVER raise.
-
-Run:
-    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
-    PYTHONPATH=$PWD .venv/bin/python -m pytest tests/test_profile_rag_isolation.py -v
-"""
-
-from __future__ import annotations
-
-import asyncio
-import sys
-import unittest
-import uuid
-from pathlib import Path
-from unittest import mock
-
-_REPO_ROOT = Path(__file__).resolve().parent.parent
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
-
-
-# ---------------------------------------------------------------------------
-# In-memory Chroma + stub embedder. We avoid touching the real
-# settings.VECTORS_DIR so tests don't pollute the prod collection.
-# ---------------------------------------------------------------------------
-
-
-def _make_ephemeral_collection():
-    """Return a fresh in-memory Chroma collection named 'policies'."""
-    import chromadb
-    from chromadb.config import Settings as ChromaSettings
-    client = chromadb.EphemeralClient(
-        settings=ChromaSettings(anonymized_telemetry=False),
-    )
-    # Use a unique name per call so parallel tests don't share state.
-    return client.get_or_create_collection(
-        name=f"policies_{uuid.uuid4().hex[:8]}",
-        metadata={"hnsw:space": "cosine"},
-    )
-
-
-class _StubEmbedder:
-    """Deterministic 8-dim embedder so semantically-similar text gets
-    semantically-similar vectors. Two profile chunks (one per named user)
-    will end up with near-identical embeddings, which is exactly what
-    triggers the pre-fix leak in the wild."""
-
-    async def embed(self, texts, input_type="document"):
-        # Hash-based but stable: every "USER CONTEXT" doc maps near the same
-        # region of the unit sphere; that's the realistic case where two
-        # users' profile chunks both look like profile chunks to cosine.
-        vecs = []
-        for t in texts:
-            base = [0.0] * 8
-            if "USER CONTEXT" in t or "profile" in t.lower():
-                # All profile-flavoured text lands near vector [1, 0, ...]
-                base = [1.0, 0.05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-            elif "age" in t.lower() or "dependents" in t.lower():
-                base = [0.9, 0.1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-            else:
-                # Generic policy text is far from the profile cluster
-                base = [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-            vecs.append(base)
-        return vecs
-
-
-# ---------------------------------------------------------------------------
-# Test cases — KI-118 threat model. Profile chunks keyed by name_slug.
-# ---------------------------------------------------------------------------
-
-
-class TestProfileIsolation(unittest.TestCase):
-    """KI-118 — anonymous sessions never write to Chroma; named user A's
-    profile must NEVER surface in named user B's retrieve."""
-
-    def setUp(self):
-        self.coll = _make_ephemeral_collection()
-        self.name_a = f"alice_{uuid.uuid4().hex[:4]}"
-        self.name_b = f"bob_{uuid.uuid4().hex[:4]}"
-
-    def _seed_profile(self, name_slug: str, text: str) -> None:
-        """Write a profile chunk for `name_slug` directly to the test
-        collection, mirroring what upsert_profile_chunk does in prod."""
-        vec = asyncio.run(_StubEmbedder().embed([text]))[0]
-        chunk_id = f"profile_{name_slug}"
-        self.coll.add(
-            ids=[chunk_id],
-            documents=[text],
-            embeddings=[vec],
-            metadatas=[{
-                "policy_id": chunk_id,
-                "insurer_slug": "profile",
-                "policy_name": f"User profile ({name_slug[:16]})",
-                "doc_type": "profile",
-                "name_slug": name_slug,  # KI-118.a — stamped at write time
-                "source_url": "",
-                "page_start": 0,
-                "page_end": 0,
-                "chunk_idx": 0,
-                "local_path": "in-memory test profile",
-            }],
-        )
-
-    def _seed_policy(self, policy_id: str, text: str) -> None:
-        """Seed a generic non-profile chunk so the main retrieval pass
-        isn't empty (otherwise we're not actually testing the filter)."""
-        vec = asyncio.run(_StubEmbedder().embed([text]))[0]
-        self.coll.add(
-            ids=[policy_id],
-            documents=[text],
-            embeddings=[vec],
-            metadatas=[{
-                "policy_id": policy_id,
-                "insurer_slug": "test-insurer",
-                "policy_name": "Test Policy",
-                "doc_type": "policy",
-                "source_url": "",
-                "page_start": 1,
-                "page_end": 1,
-                "chunk_idx": 0,
-            }],
-        )
-
-    def _run_retrieve(self, query: str, profile_name_slug: str, top_k: int = 5):
-        """Invoke rag.retrieve.retrieve() with the test collection +
-        stub embedder patched in."""
-        from rag import retrieve as retrieve_mod
-        # Clear the in-process cache so each test sees a fresh execution
-        retrieve_mod._RETRIEVAL_CACHE.clear()
-        with mock.patch.object(retrieve_mod, "get_collection", return_value=self.coll):
-            return asyncio.run(retrieve_mod.retrieve(
-                query=query,
-                top_k=top_k,
-                embedder=_StubEmbedder(),
-                profile_name_slug=profile_name_slug,
-            ))
-
-    # -----------------------------------------------------------------
-    # CASE 1 — pre-fix leak repro: named user A's profile must NOT show
-    # up in named user B's retrieved context.
-    # -----------------------------------------------------------------
-    def test_name_a_profile_never_leaks_into_name_b(self):
-        self._seed_profile(
-            self.name_a,
-            "USER CONTEXT — facts about the person asking this question:\n"
-            "- Age: 45 years.\n- User's own pre-existing conditions: diabetes, hypertension.",
-        )
-        self._seed_profile(
-            self.name_b,
-            "USER CONTEXT — facts about the person asking this question:\n"
-            "- Age: 28 years.\n- First-time buyer; no existing health insurance.",
-        )
-        # Add a generic policy chunk so there's something to retrieve.
-        self._seed_policy("hdfc_ergo_optima_secure_v1", "Standard health policy text about waiting periods.")
-
-        # User B asks a profile-flavoured query
-        chunks = self._run_retrieve(
-            query="what plan suits my age and dependents",
-            profile_name_slug=self.name_b,
-        )
-
-        leaked = [c for c in chunks if c.policy_id == f"profile_{self.name_a}"]
-        self.assertEqual(
-            leaked, [],
-            f"PRIVACY LEAK: user A's profile chunk surfaced in user B's "
-            f"retrieval. Found: {[c.policy_id for c in chunks]}",
-        )
-
-    # -----------------------------------------------------------------
-    # CASE 2 — named user B's OWN profile must still surface (positive path).
-    # -----------------------------------------------------------------
-    def test_name_b_own_profile_is_surfaced(self):
-        self._seed_profile(
-            self.name_b,
-            "USER CONTEXT — facts about the person asking this question:\n"
-            "- Age: 28 years.",
-        )
-        self._seed_policy("test_policy_1", "Generic policy text.")
-
-        chunks = self._run_retrieve(
-            query="recommend a plan for me",
-            profile_name_slug=self.name_b,
-        )
-        own = [c for c in chunks if c.policy_id == f"profile_{self.name_b}"]
-        self.assertEqual(
-            len(own), 1,
-            f"User B should see its OWN profile chunk. Got: {[c.policy_id for c in chunks]}",
-        )
-
-    # -----------------------------------------------------------------
-    # CASE 3 — multiple foreign profiles + one own profile. Only the
-    # current user's chunk may be present.
-    # -----------------------------------------------------------------
-    def test_three_foreign_profiles_none_leak(self):
-        for name in ["alice_1", "carol_2", "dave_3"]:
-            self._seed_profile(
-                name,
-                f"USER CONTEXT — facts about the person asking this question:\n"
-                f"- Age: {30 + len(name)} years.\n- Health conditions: PII for {name}.",
-            )
-        self._seed_profile(
-            self.name_b,
-            "USER CONTEXT — facts about the person asking this question:\n- Age: 28 years.",
-        )
-        self._seed_policy("test_policy_2", "Generic policy text.")
-
-        chunks = self._run_retrieve(
-            query="my age health conditions dependents",
-            profile_name_slug=self.name_b,
-            top_k=10,
-        )
-        profile_pids = [c.policy_id for c in chunks if c.doc_type == "profile"]
-        # Only ONE profile chunk may appear, and it must be name_b's
-        self.assertEqual(
-            profile_pids, [f"profile_{self.name_b}"],
-            f"Foreign profile leaked. profile chunks in result: {profile_pids}",
-        )
-
-    # -----------------------------------------------------------------
-    # CASE 4 — legacy chunk without name_slug metadata is refused even
-    # if its id happens to match (defence-in-depth from KI-118.b).
-    # -----------------------------------------------------------------
-    def test_legacy_chunk_without_name_slug_metadata_is_refused(self):
-        # Write a chunk under id 'profile_<name_b>' but with NO
-        # name_slug field (simulating a pre-KI-118 legacy row).
-        vec = asyncio.run(_StubEmbedder().embed(["USER CONTEXT — legacy"]))[0]
-        chunk_id = f"profile_{self.name_b}"
-        self.coll.add(
-            ids=[chunk_id],
-            documents=["USER CONTEXT — legacy row from before KI-118 deploy"],
-            embeddings=[vec],
-            metadatas=[{
-                "policy_id": chunk_id,
-                "insurer_slug": "profile",
-                "policy_name": "legacy profile",
-                "doc_type": "profile",
-                # No 'name_slug' — simulating pre-fix state
-                "source_url": "",
-                "page_start": 0,
-                "page_end": 0,
-                "chunk_idx": 0,
-            }],
-        )
-        self._seed_policy("test_policy_3", "Generic policy text.")
-
-        chunks = self._run_retrieve(
-            query="anything",
-            profile_name_slug=self.name_b,
-        )
-        # Legacy chunk must be refused — the triple-check at retrieve's
-        # per-name lookup gates on metadata.name_slug match.
-        legacy_hits = [c for c in chunks if c.policy_id == chunk_id]
-        self.assertEqual(
-            legacy_hits, [],
-            "Legacy profile chunk without name_slug metadata must be refused. "
-            f"Got: {[c.policy_id for c in chunks]}",
-        )
-
-    # -----------------------------------------------------------------
-    # CASE 5 — KI-118 core invariant: anonymous calls (no profile_name_slug)
-    # produce NO profile chunks at all, even if the collection contains
-    # foreign profile rows that match the query.
-    # -----------------------------------------------------------------
-    def test_anonymous_retrieve_never_surfaces_any_profile_chunk(self):
-        # Seed two named-user profiles
-        self._seed_profile(self.name_a, "USER CONTEXT — Age: 45 years.")
-        self._seed_profile(self.name_b, "USER CONTEXT — Age: 28 years.")
-        self._seed_policy("test_policy_anon", "Generic policy text.")
-
-        # Anonymous call — no profile_name_slug
-        from rag import retrieve as retrieve_mod
-        retrieve_mod._RETRIEVAL_CACHE.clear()
-        with mock.patch.object(retrieve_mod, "get_collection", return_value=self.coll):
-            chunks = asyncio.run(retrieve_mod.retrieve(
-                query="my age health conditions",
-                top_k=5,
-                embedder=_StubEmbedder(),
-                profile_name_slug=None,
-            ))
-        profile_chunks = [c for c in chunks if c.doc_type == "profile"]
-        self.assertEqual(
-            profile_chunks, [],
-            "PRIVACY LEAK: anonymous retrieve surfaced a profile chunk. "
-            f"Got: {[c.policy_id for c in chunks]}",
-        )
-
-
-# ---------------------------------------------------------------------------
-# KI-107 (2026-05-15) — graceful handling of Chroma get(ids=[missing]).
-# C5 port-in persona saw 3× HTTP 500 "Error executing plan: Internal error:
-# Error finding id". After KI-102 added the per-session profile-chunk
-# lookup, retrieve() runs collection.get(ids=[f"profile_{slug}"]) on EVERY
-# named query — and for new users (no profile saved yet) and certain
-# Chroma sqlite states, that call can raise. These tests pin the contract:
-# retrieve() with a never-existed name_slug must NEVER raise and must
-# NEVER return a profile chunk.
-# ---------------------------------------------------------------------------
-
-
-class TestRetrieveSurvivesMissingProfileId(unittest.TestCase):
-    """KI-107 — retrieve(profile_name_slug=...) must be exception-safe across:
-    (1) first-time named users with no profile chunk yet,
-    (2) Chroma.get raising on the per-name lookup,
-    (3) Chroma.get returning empty lists for missing ids."""
-
-    def setUp(self):
-        self.coll = _make_ephemeral_collection()
-
-    def _seed_one_policy(self):
-        """Seed a single policy chunk so the main cosine pass returns something."""
-        vec = asyncio.run(_StubEmbedder().embed(["Standard policy text."]))[0]
-        self.coll.add(
-            ids=["policy_seed_1"],
-            documents=["Standard policy text about waiting periods."],
-            embeddings=[vec],
-            metadatas=[{
-                "policy_id": "policy_seed_1",
-                "insurer_slug": "test-insurer",
-                "policy_name": "Test Policy",
-                "doc_type": "policy",
-                "source_url": "",
-                "page_start": 1,
-                "page_end": 1,
-                "chunk_idx": 0,
-            }],
-        )
-
-    def _run_retrieve(self, query: str, profile_name_slug: str, top_k: int = 5):
-        from rag import retrieve as retrieve_mod
-        retrieve_mod._RETRIEVAL_CACHE.clear()
-        with mock.patch.object(retrieve_mod, "get_collection", return_value=self.coll):
-            return asyncio.run(retrieve_mod.retrieve(
-                query=query,
-                top_k=top_k,
-                embedder=_StubEmbedder(),
-                profile_name_slug=profile_name_slug,
-            ))
-
-    def test_retrieve_with_never_existed_name_does_not_raise(self):
-        """First-time named user, no profile saved yet — must return policy
-        chunks without raising. Pre-KI-107 this surfaced as HTTP 500 "Error
-        finding id" because get(ids=[missing]) raised + bare except: pass
-        let downstream code index into a None result."""
-        self._seed_one_policy()
-
-        # Should not raise
-        chunks = self._run_retrieve(
-            query="what is the waiting period for cataract",
-            profile_name_slug="never_existed_name_xyz",
-        )
-
-        # No profile chunk should appear (none was ever written)
-        profile_chunks = [c for c in chunks if c.doc_type == "profile"]
-        self.assertEqual(
-            profile_chunks, [],
-            f"never-existed name should not produce profile chunks. "
-            f"Got: {[(c.chunk_id, c.doc_type) for c in chunks]}",
-        )
-        # But main cosine retrieval must still work
-        self.assertGreater(
-            len(chunks), 0,
-            "main cosine pass should still return the seeded policy chunk.",
-        )
-
-    def test_retrieve_handles_chroma_get_raising_on_per_name_lookup(self):
-        """Simulate the worst case: Chroma raises on the per-name profile
-        lookup (e.g. transient sqlite lock during compaction). retrieve()
-        must still return main cosine results, not 500."""
-        self._seed_one_policy()
-
-        # Wrap the real collection so .get() raises but .query() works
-        real_coll = self.coll
-
-        class _RaisingGetWrapper:
-            def __init__(self, inner):
-                self._inner = inner
-
-            def query(self, *args, **kwargs):
-                return self._inner.query(*args, **kwargs)
-
-            def get(self, *args, **kwargs):
-                raise RuntimeError("Error finding id: simulated chroma failure")
-
-        wrapped = _RaisingGetWrapper(real_coll)
-
-        from rag import retrieve as retrieve_mod
-        retrieve_mod._RETRIEVAL_CACHE.clear()
-        with mock.patch.object(retrieve_mod, "get_collection", return_value=wrapped):
-            # Must NOT raise — _safe_collection_get swallows + logs
-            chunks = asyncio.run(retrieve_mod.retrieve(
-                query="what is the waiting period",
-                top_k=5,
-                embedder=_StubEmbedder(),
-                profile_name_slug="some_name_slug",
-            ))
-
-        # Main cosine still works → at least the seeded policy chunk returns
-        self.assertGreater(
-            len(chunks), 0,
-            "retrieve() should fall back to main cosine results when "
-            "the per-name profile lookup raises.",
-        )
-        # No profile chunk surfaced
-        self.assertEqual(
-            [c for c in chunks if c.doc_type == "profile"], [],
-            "raising get() must NOT produce a profile chunk in the result.",
-        )
-
-    def test_safe_collection_get_returns_none_on_exception(self):
-        """Unit-test the _safe_collection_get helper directly."""
-        from rag.retrieve import _safe_collection_get
-
-        class _Raiser:
-            def get(self, **kw):
-                raise RuntimeError("Error finding id")
-
-        result = _safe_collection_get(_Raiser(), ids=["x"], include=["documents"])
-        self.assertIsNone(
-            result,
-            "_safe_collection_get must return None on exception, not re-raise.",
-        )
-
-    def test_safe_collection_get_returns_empty_dict_on_miss(self):
-        """When ids miss but Chroma returns empty lists (the normal case),
-        _safe_collection_get returns the raw dict — caller decides what to
-        do with empty lists (the truthiness check filters them out)."""
-        from rag.retrieve import _safe_collection_get
-
-        result = _safe_collection_get(
-            self.coll,
-            ids=["definitely_does_not_exist"],
-            include=["documents", "metadatas"],
-        )
-        # Should return a dict (not None), with empty ids list
-        self.assertIsNotNone(result, "missing-id get must not return None")
-        self.assertEqual(result.get("ids"), [], "missing id should yield empty ids list")
-
-
-# ---------------------------------------------------------------------------
-# Standalone upsert metadata test — no Chroma client; just verify the
-# upsert builds metadata containing name_slug.
-# ---------------------------------------------------------------------------
-
-
-class TestUpsertStampsNameSlug(unittest.TestCase):
-    """KI-118.a — upsert_profile_chunk MUST write name_slug into the
-    chunk's Chroma metadata. Without it, the retrieve filter can't
-    distinguish user A's profile from user B's."""
-
-    def test_upsert_writes_name_slug_to_metadata(self):
-        from backend import profile_rag
-
-        captured: dict = {}
-
-        class _FakeColl:
-            def add(self, ids, documents, embeddings, metadatas):
-                captured["ids"] = ids
-                captured["metadatas"] = metadatas
-
-            def delete(self, where=None):
-                captured["deleted_where"] = where
-
-        class _FakeEmbedder:
-            # KI-112 (2026-05-15) — the upsert path now validates that the
-            # embedding length matches embedder.dimension. Set both to 384 so
-            # the realistic-shape vector passes the shape check; the test's
-            # subject under scrutiny is the metadata stamping, not the shape
-            # guard (those have dedicated cases below).
-            dimension = 384
-
-            async def embed(self, texts, input_type="document"):
-                return [[0.1] * 384 for _ in texts]
-
-        fake_coll = _FakeColl()
-        slug = f"alice_{uuid.uuid4().hex[:6]}"
-        profile = {
-            "age": 32,
-            "dependents": "self_spouse",
-            "health_conditions": [],
-            "existing_cover_inr": 500000,
-        }
-
-        with mock.patch.object(profile_rag, "_get_collection", return_value=fake_coll), \
-             mock.patch("backend.providers.local_embeddings.LocalEmbeddings", _FakeEmbedder):
-            asyncio.run(profile_rag.upsert_profile_chunk(slug, profile))
-
-        self.assertIn("metadatas", captured, "upsert never called coll.add")
-        meta = captured["metadatas"][0]
-        self.assertEqual(
-            meta.get("name_slug"), slug,
-            f"profile chunk metadata missing name_slug. Got: {meta}",
-        )
-        self.assertEqual(meta.get("doc_type"), "profile")
-        self.assertEqual(captured["ids"], [f"profile_{slug}"])
-
-
-# ---------------------------------------------------------------------------
-# KI-112 (2026-05-15) — input validation hardening (still applies post-KI-118).
-#
-# Root cause of the historical HNSW corruption: KI-102's initial deploy wrote
-# a profile chunk under id "profile_anonymous" with NO session_id metadata.
-# That legacy chunk poisoned every subsequent collection.query() that
-# referenced session_id or doc_type$ne in the where clause — Chroma's plan
-# executor raised "Error finding id" against the dangling row's HNSW pointer.
-#
-# KI-118 moved the key from session_id to name_slug; the guards are the same.
-# These tests pin the contract: bad inputs MUST be rejected at write time,
-# not silently corrupt the index for future users.
-# ---------------------------------------------------------------------------
-
-
-class TestUpsertRejectsBadInputs(unittest.TestCase):
-    """KI-112 / KI-118 — bad name_slug or embedding shape must NOT reach Chroma."""
-
-    def test_upsert_rejects_empty_name_slug(self):
-        from backend import profile_rag
-
-        captured: dict = {"add_called": False}
-
-        class _FakeColl:
-            def add(self, ids, documents, embeddings, metadatas):
-                captured["add_called"] = True
-
-            def delete(self, where=None):
-                captured["delete_called"] = True
-
-        class _FakeEmbedder:
-            dimension = 384
-
-            async def embed(self, texts, input_type="document"):
-                return [[0.1] * 384 for _ in texts]
-
-        for bad_slug in ["", "   ", None]:
-            with mock.patch.object(profile_rag, "_get_collection", return_value=_FakeColl()), \
-                 mock.patch("backend.providers.local_embeddings.LocalEmbeddings", _FakeEmbedder):
-                captured["add_called"] = False
-                asyncio.run(profile_rag.upsert_profile_chunk(bad_slug, {"age": 30}))
-            self.assertFalse(
-                captured["add_called"],
-                f"upsert MUST refuse name_slug={bad_slug!r} — bad write would "
-                "corrupt the policies collection.",
-            )
-
-    def test_upsert_rejects_mismatched_embedding_dim(self):
-        """If the embedder somehow returns the wrong dim (model drift,
-        misconfig), upsert must NOT write it to Chroma."""
-        from backend import profile_rag
-
-        captured: dict = {"add_called": False}
-
-        class _FakeColl:
-            def add(self, ids, documents, embeddings, metadatas):
-                captured["add_called"] = True
-
-            def delete(self, where=None):
-                pass
-
-        class _BadDimEmbedder:
-            dimension = 384
-
-            async def embed(self, texts, input_type="document"):
-                # Wrong dim — 8-dim stub like other tests, but profile_rag
-                # expects 384.
-                return [[0.1] * 8 for _ in texts]
-
-        with mock.patch.object(profile_rag, "_get_collection", return_value=_FakeColl()), \
-             mock.patch("backend.providers.local_embeddings.LocalEmbeddings", _BadDimEmbedder):
-            asyncio.run(profile_rag.upsert_profile_chunk(
-                "valid_slug_xyz", {"age": 30, "dependents": "self"},
-            ))
-
-        self.assertFalse(
-            captured["add_called"],
-            "upsert MUST refuse a mis-shaped embedding to prevent HNSW "
-            "corruption from a model drift event.",
-        )
-
-    def test_upsert_rejects_none_in_embedding(self):
-        from backend import profile_rag
-
-        captured: dict = {"add_called": False}
-
-        class _FakeColl:
-            def add(self, ids, documents, embeddings, metadatas):
-                captured["add_called"] = True
-
-            def delete(self, where=None):
-                pass
-
-        class _NoneVecEmbedder:
-            dimension = 384
-
-            async def embed(self, texts, input_type="document"):
-                vec = [0.1] * 384
-                vec[42] = None  # one None value
-                return [vec for _ in texts]
-
-        with mock.patch.object(profile_rag, "_get_collection", return_value=_FakeColl()), \
-             mock.patch("backend.providers.local_embeddings.LocalEmbeddings", _NoneVecEmbedder):
-            asyncio.run(profile_rag.upsert_profile_chunk(
-                "valid_slug_xyz", {"age": 30, "dependents": "self"},
-            ))
-
-        self.assertFalse(
-            captured["add_called"],
-            "upsert MUST refuse a vector containing None values.",
-        )
-
-    def test_upsert_accepts_correct_shape(self):
-        """Positive path — a well-formed 384-dim list must be persisted."""
-        from backend import profile_rag
-
-        captured: dict = {}
-
-        class _FakeColl:
-            def add(self, ids, documents, embeddings, metadatas):
-                captured["ids"] = ids
-                captured["embeddings"] = embeddings
-
-            def delete(self, where=None):
-                pass
-
-        class _GoodEmbedder:
-            dimension = 384
-
-            async def embed(self, texts, input_type="document"):
-                return [[0.1] * 384 for _ in texts]
-
-        with mock.patch.object(profile_rag, "_get_collection", return_value=_FakeColl()), \
-             mock.patch("backend.providers.local_embeddings.LocalEmbeddings", _GoodEmbedder):
-            asyncio.run(profile_rag.upsert_profile_chunk(
-                "good_slug", {"age": 30, "dependents": "self"},
-            ))
-
-        self.assertEqual(captured.get("ids"), ["profile_good_slug"])
-        self.assertEqual(len(captured["embeddings"][0]), 384)
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_profile_recall_session_isolation.py

@@ -1,289 +0,0 @@
-"""Regression tests — fresh no-cookie session must NOT inherit a stranger's
-profile via a weak/shared name key (privacy audit, 2026-05-16).
-
-AUDIT FINDING
--------------
-A live test opened a FRESH browser context with zero cookies and was still
-greeted "Welcome back, Rahul! … Based on our last conversation…" — the
-backend restored a prior on-disk profile into a brand-new session.
-
-ROOT CAUSE
-----------
-The turn-1 recall path was keyed on the user-STATED NAME, not the session:
-
-    single_brain.handle_turn (turn 1)
-      -> profile_persistence.try_recall_by_name(session, name)
-      -> session_state.rehydrate_by_name(session, name)
-      -> profile_store.load_profile(name)        # <-- name-slug keyed file
-         + a directory scan that returned ANY persona-id file whose stored
-           display-name matched the slug.
-
-So a second real user on a shared browser/IP — or anyone who simply states
-a common first name ("I'm Rahul") — was AUTO-MERGED a stranger's captured
-profile and greeted "Welcome back" with no confirmation.
-
-INTENDED SAFE DESIGN (KI-196 / ADR-041, specced but never wired)
-----------------------------------------------------------------
-`SessionState.pending_profile_recall` — a name match is STAGED, not merged.
-The profile is only applied after an EXPLICIT user affirmation. A fresh
-session is NEVER silently greeted with a stored stranger profile.
-
-These tests pin:
-
-  1. try_recall_by_name does NOT auto-merge a stored profile into a fresh
-     session; it stages it on `session.pending_profile_recall`.
-  2. After staging, `session.profile` still has NO recalled fields → the
-     "Welcome back" / is_returning_user signal stays False.
-  3. An explicit AFFIRM (apply_pending_recall) merges the staged profile —
-     legitimate returning-user continuity is preserved.
-  4. An explicit DENY discards the staged profile and leaves the session
-     blank.
-  5. Same-session continuity (slots captured within THIS conversation)
-     is untouched — only cross-session NAME recall is gated.
-  6. load_profile no longer leaks a stranger's persona-id file via the
-     display-name directory scan (cross-identity leak vector removed).
-
-Run:
-    cd /Users/rohitsar/Developer/Insurance\\ Sales\\ Bot
-    PYTHONPATH=$PWD .venv/bin/python -m pytest \\
-        tests/test_profile_recall_session_isolation.py -v
-"""
-
-from __future__ import annotations
-
-import json
-import sys
-import tempfile
-import unittest
-import uuid
-from pathlib import Path
-from unittest import mock
-
-_REPO_ROOT = Path(__file__).resolve().parent.parent
-if str(_REPO_ROOT) not in sys.path:
-    sys.path.insert(0, str(_REPO_ROOT))
-
-from backend.needs_finder import Profile  # noqa: E402
-
-
-def _write_stored_profile(profiles_dir: Path, slug: str, prof_fields: dict,
-                          *, display: str, persona_id: str | None = None):
-    """Write a profile JSON the way profile_store.save_profile would."""
-    profiles_dir.mkdir(parents=True, exist_ok=True)
-    fname = f"{persona_id}.json" if persona_id else f"{slug}.json"
-    payload = {
-        "name_display": display,
-        "name_slug": slug,
-        "persona_id": persona_id,
-        "profile": {**{f.name: getattr(Profile(), f.name)
-                       for f in Profile.__dataclass_fields__.values()},
-                     **prof_fields},
-        "first_seen": "2026-05-15T00:00:00Z",
-        "last_seen": "2026-05-15T00:00:00Z",
-        "sessions": ["stranger_sess_1"],
-    }
-    (profiles_dir / fname).write_text(json.dumps(payload, indent=2, default=str))
-
-
-class _ProfilesDirMixin(unittest.TestCase):
-    """Point profile_store at an isolated temp profiles dir for the test."""
-
-    def setUp(self):
-        self._tmp = tempfile.TemporaryDirectory()
-        self._profiles_dir = Path(self._tmp.name) / "profiles"
-        self._profiles_dir.mkdir(parents=True, exist_ok=True)
-        # profile_store reads module-level _PROFILES_DIR for every path op.
-        import backend.profile_store as ps
-        self._ps = ps
-        self._patch = mock.patch.object(ps, "_PROFILES_DIR", self._profiles_dir)
-        self._patch.start()
-
-    def tearDown(self):
-        self._patch.stop()
-        self._tmp.cleanup()
-
-
-class TestFreshSessionDoesNotInheritStrangerProfile(_ProfilesDirMixin):
-    """Core privacy guarantee."""
-
-    def _fresh_session(self):
-        from backend.session_state import SessionState
-        return SessionState(session_id=f"fresh_{uuid.uuid4().hex[:8]}")
-
-    def test_try_recall_by_name_does_not_auto_merge(self):
-        """A stranger named 'Rahul' has a stored profile. A FRESH session
-        states 'Rahul' on turn 1. The stored profile must NOT be merged
-        into session.profile, and must NOT flag a returning user."""
-        _write_stored_profile(
-            self._profiles_dir, "rahul",
-            {"name": "Rahul", "age": 41, "dependents": "self+spouse+kids",
-             "location_tier": "metro", "income_band": "10L-25L"},
-            display="Rahul",
-        )
-
-        from backend.profile_persistence import try_recall_by_name
-
-        sess = self._fresh_session()
-        result = try_recall_by_name(sess, "Rahul")
-
-        # NOT auto-applied → caller must not treat as returning user.
-        self.assertFalse(
-            result,
-            "REGRESSION (privacy): try_recall_by_name auto-merged a stored "
-            "stranger profile into a fresh session. It must stage, not merge.",
-        )
-        # session.profile must still be blank — no leaked PII.
-        self.assertIsNone(sess.profile.age)
-        self.assertIsNone(sess.profile.dependents)
-        self.assertIsNone(sess.profile.location_tier)
-        self.assertIn(
-            sess.profile.name, (None, ""),
-            "REGRESSION (privacy): stranger name leaked onto fresh session.",
-        )
-
-    def test_match_is_staged_for_confirmation(self):
-        """The match IS detected — it's staged on pending_profile_recall so
-        the brain can ASK 'are you Rahul?' rather than silently greet."""
-        _write_stored_profile(
-            self._profiles_dir, "rahul",
-            {"name": "Rahul", "age": 41, "location_tier": "metro"},
-            display="Rahul",
-        )
-        from backend.profile_persistence import try_recall_by_name
-
-        sess = self._fresh_session()
-        try_recall_by_name(sess, "Rahul")
-
-        self.assertIsNotNone(
-            sess.pending_profile_recall,
-            "Expected the name match to be STAGED on pending_profile_recall.",
-        )
-        self.assertEqual(sess.pending_profile_recall["name"], "Rahul")
-        # Staged summary carries identity hints for the confirm prompt, but
-        # they are NOT on the live profile.
-        self.assertIn("summary", sess.pending_profile_recall)
-        self.assertIsNone(sess.profile.age)
-
-    def test_no_match_stages_nothing(self):
-        """Distinct identity with no stored file → no staging, no leak
-        (mirrors the Zenobia control from the audit)."""
-        from backend.profile_persistence import try_recall_by_name
-
-        sess = self._fresh_session()
-        result = try_recall_by_name(sess, "Zenobia")
-        self.assertFalse(result)
-        self.assertIsNone(sess.pending_profile_recall)
-        self.assertIsNone(sess.profile.age)
-
-
-class TestExplicitConfirmationFlow(_ProfilesDirMixin):
-    """Legitimate returning-user continuity must still work — on opt-in."""
-
-    def test_affirm_applies_staged_profile(self):
-        _write_stored_profile(
-            self._profiles_dir, "priya",
-            {"name": "Priya", "age": 33, "dependents": "self+spouse",
-             "location_tier": "tier1"},
-            display="Priya",
-        )
-        from backend.profile_persistence import try_recall_by_name
-        from backend.session_state import SessionState, apply_pending_recall
-
-        sess = SessionState(session_id="ret_user_1")
-        try_recall_by_name(sess, "Priya")
-        self.assertIsNotNone(sess.pending_profile_recall)
-
-        # User explicitly confirms "yes, that's me".
-        applied = apply_pending_recall(sess, confirmed=True)
-        self.assertTrue(applied)
-        self.assertEqual(sess.profile.name, "Priya")
-        self.assertEqual(sess.profile.age, 33)
-        self.assertEqual(sess.profile.dependents, "self+spouse")
-        self.assertEqual(sess.profile.location_tier, "tier1")
-        # Staging cleared after apply.
-        self.assertIsNone(sess.pending_profile_recall)
-
-    def test_deny_discards_staged_profile(self):
-        _write_stored_profile(
-            self._profiles_dir, "rahul",
-            {"name": "Rahul", "age": 41, "location_tier": "metro"},
-            display="Rahul",
-        )
-        from backend.profile_persistence import try_recall_by_name
-        from backend.session_state import SessionState, apply_pending_recall
-
-        sess = SessionState(session_id="not_rahul_1")
-        try_recall_by_name(sess, "Rahul")
-        self.assertIsNotNone(sess.pending_profile_recall)
-
-        # User says "no, I'm not Rahul" (or just continues with new facts).
-        applied = apply_pending_recall(sess, confirmed=False)
-        self.assertFalse(applied)
-        self.assertIsNone(sess.pending_profile_recall)
-        self.assertIsNone(sess.profile.age)
-        self.assertIn(sess.profile.name, (None, ""))
-
-
-class TestSameSessionContinuityPreserved(_ProfilesDirMixin):
-    """Slots captured within THIS conversation must never be gated/lost."""
-
-    def test_in_conversation_capture_untouched(self):
-        from backend.session_state import get_session, reset_session
-
-        sid = f"same_sess_{uuid.uuid4().hex[:8]}"
-        reset_session(sid)
-        sess = get_session(sid)
-        # Simulate brain_tools.save_profile_field within this conversation.
-        sess.profile.name = "Anjali"
-        sess.profile.age = 29
-        sess.profile.location_tier = "tier2"
-
-        # Same-session continuity is in-memory and must persist verbatim.
-        again = get_session(sid)
-        self.assertIs(again, sess)
-        self.assertEqual(again.profile.name, "Anjali")
-        self.assertEqual(again.profile.age, 29)
-        self.assertEqual(again.profile.location_tier, "tier2")
-        self.assertIsNone(again.pending_profile_recall)
-        reset_session(sid)
-
-
-class TestLoadProfileNoCrossIdentityScan(_ProfilesDirMixin):
-    """The display-name directory scan in load_profile was a pure leak
-    vector — a fresh visitor stating a common first name pulled a random
-    persona-id file. It must no longer cross identities."""
-
-    def test_persona_id_file_not_returned_by_bare_name(self):
-        # Stranger stored under a persona-id filename (different age/city),
-        # NOT under the bare name slug.
-        _write_stored_profile(
-            self._profiles_dir, "rohit",
-            {"name": "Rohit", "age": 52, "location_tier": "tier3"},
-            display="Rohit", persona_id="deadbeef1234",
-        )
-        # No rohit.json (bare slug) exists.
-        self.assertFalse((self._profiles_dir / "rohit.json").exists())
-
-        loaded = self._ps.load_profile("Rohit")  # no persona_id supplied
-        self.assertIsNone(
-            loaded,
-            "REGRESSION (privacy): load_profile returned a stranger's "
-            "persona-id-keyed profile via the display-name directory scan. "
-            "Bare-name lookup must NOT cross persona identities.",
-        )
-
-    def test_exact_slug_file_still_loads(self):
-        """Legitimate same-name slug file (the user's own) still resolves —
-        we only removed the cross-persona scan, not the direct slug path."""
-        _write_stored_profile(
-            self._profiles_dir, "meera",
-            {"name": "Meera", "age": 38},
-            display="Meera",
-        )
-        loaded = self._ps.load_profile("Meera")
-        self.assertIsNotNone(loaded)
-        self.assertEqual(loaded.age, 38)
-
-
-if __name__ == "__main__":
-    unittest.main(verbosity=2)

tests/test_returning_user_recall_singlebrain.py

@@ -1,202 +0,0 @@
-"""Regression test for the returning-user-by-name recall fix (2026-05-19).
-
-Bug: every visit, the user gave the same name ("Rohit") and the bot NEVER
-asked "are you the same Rohit?" / never recalled the stored profile. The
-confirmation-gated recall (ADR-041/KI-196) helpers existed and were
-unit-tested, but the orchestrator→single-LLM rewrite left them ORPHANED —
-nothing on the live path (single_brain.handle_turn) called them, and
-`returning_user_recalled` was a hard-coded False. The integration boundary
-was exactly what had no test (that's how it shipped).
-
-These tests pin the now-wired chain end-to-end in single_brain:
-  turn-1 name sniff → stage (privacy-safe, never auto-merge) → confirm
-  prompt injected → explicit "yes" merges + flips returning_user_recalled
-  → explicit "no" discards → unknown name is a no-op (no false prompt).
-"""
-import asyncio
-import os
-import random
-import string
-import unittest
-import uuid
-from unittest import mock
-
-from backend import single_brain
-from backend import brain_tools
-from backend.session_state import SessionState, apply_pending_recall
-from backend.profile_persistence import extract_potential_name, try_recall_by_name
-from backend.profile_store import save_profile, _normalise_name, _PROFILES_DIR
-from backend.needs_finder import Profile
-
-
-def _run(coro):
-    return asyncio.new_event_loop().run_until_complete(coro)
-
-
-def _text_payload(text):
-    return {"candidates": [{"content": {"parts": [{"text": text}]}}]}
-
-
-class TestAffirmOrDeny(unittest.TestCase):
-    """Word-boundary yes/no — must NOT read 'no' inside 'knows'/'now', and
-    deny must win ties (privacy fail-closed)."""
-
-    def test_table(self):
-        cases = [
-            ("yes that is me", True),
-            ("yeah, same Rohit", True),
-            ("haan bilkul", True),
-            ("that is me, carry on", True),
-            ("no, I'm a new user", False),
-            ("not me, someone else", False),
-            ("no, but yes", False),          # deny wins
-            ("i don't know", False),         # fail-closed
-            ("maybe, who knows", None),      # 'knows' must NOT be 'no'
-            ("now what", None),              # 'now' must NOT be 'no'
-            ("hmm", None),
-            ("", None),
-        ]
-        for txt, exp in cases:
-            self.assertEqual(single_brain._affirm_or_deny(txt), exp, txt)
-
-
-class _StoredProfileFixture(unittest.TestCase):
-    """Creates a deterministic, uniquely-named stored profile so the test
-    never couples to the mutable 40-data/profiles/rohit.json."""
-
-    def setUp(self):
-        # Alphabetic only — extract_potential_name correctly rejects
-        # digit-bearing tokens, so a hex suffix would never be sniffed.
-        self.name = "Recalltester" + "".join(
-            random.choices(string.ascii_lowercase, k=7))
-        self.slug = _normalise_name(self.name)
-        p = Profile()
-        p.name = self.name
-        p.age = 41
-        p.dependents = "self+spouse+1 kid"
-        p.location_tier = "metro"
-        p.income_band = "10L-25L"
-        p.primary_goal = "first_buy"
-        p.health_conditions = ["none"]
-        self.assertTrue(save_profile(self.name, p),
-                        "fixture save_profile failed")
-
-    def tearDown(self):
-        try:
-            for fp in _PROFILES_DIR.glob("*.json"):
-                try:
-                    import json
-                    d = json.loads(fp.read_text())
-                except Exception:
-                    continue
-                if d.get("name_slug") == self.slug or \
-                   (d.get("profile") or {}).get("name") == self.name:
-                    fp.unlink(missing_ok=True)
-        except Exception:
-            pass
-
-
-class TestRecallChain(_StoredProfileFixture):
-    def test_stage_inject_merge(self):
-        nm = extract_potential_name(f"Hi, I'm {self.name}")
-        self.assertTrue(nm and nm.lower().startswith("recalltester"))
-        s = SessionState(session_id="rc1")
-        try_recall_by_name(s, nm)
-        pr = getattr(s, "pending_profile_recall", None)
-        self.assertTrue(pr, "name match was not STAGED")
-        self.assertEqual(pr["name"], self.name)
-        si = single_brain._system_instruction(
-            s.profile, pending_recall=pr)["parts"][0]["text"]
-        self.assertIn("RETURNING-USER CHECK", si)
-        self.assertIn("Welcome back", si)
-        self.assertIn(self.name, si)
-        # confirm=True merges into empty slots
-        self.assertTrue(apply_pending_recall(s, confirmed=True))
-        self.assertEqual(s.profile.age, 41)
-        self.assertIsNone(getattr(s, "pending_profile_recall", None))
-
-    def test_deny_discards(self):
-        s = SessionState(session_id="rc2")
-        try_recall_by_name(s, self.name)
-        self.assertTrue(s.pending_profile_recall)
-        self.assertFalse(apply_pending_recall(s, confirmed=False))
-        self.assertIn(getattr(s.profile, "age", None), (None, "", 0))
-        self.assertIsNone(s.pending_profile_recall)
-
-    def test_unknown_name_no_stage(self):
-        s = SessionState(session_id="rc3")
-        try_recall_by_name(s, "Zzqxnobodyhasthisname")
-        self.assertIsNone(getattr(s, "pending_profile_recall", None))
-
-
-class TestHandleTurnIntegration(_StoredProfileFixture):
-    """The exact gap that let the bug ship: single_brain.handle_turn
-    integration with the recall chain."""
-
-    def setUp(self):
-        super().setUp()
-        self._env = mock.patch.dict(os.environ,
-                                    {"GOOGLE_API_KEY": "test-key"})
-        self._env.start()
-        self.sys_prompts = []
-
-        async def _fake_gemini(*_a, **_k):
-            self.sys_prompts.append(
-                (_k.get("system_instruction") or {})
-                .get("parts", [{}])[0].get("text", ""))
-            return _text_payload("Welcome back — are you the same person?")
-
-        self._gp = mock.patch.object(single_brain, "_gemini_call",
-                                     _fake_gemini)
-        self._gp.start()
-
-    def tearDown(self):
-        self._gp.stop()
-        self._env.stop()
-        super().tearDown()
-
-    def test_turn1_stages_and_prompts_then_yes_recalls(self):
-        sess = SessionState(session_id=f"hti_{uuid.uuid4().hex[:8]}")
-        # Turn 1: user states their (returning) name.
-        r1 = _run(single_brain.handle_turn(sess, f"Hi, I'm {self.name}"))
-        self.assertTrue(getattr(sess, "pending_profile_recall", None),
-                        "turn-1 name sniff did not STAGE the recall")
-        self.assertFalse(r1.returning_user_recalled,
-                         "must NOT flag recall before the user confirms")
-        self.assertIn("RETURNING-USER CHECK", self.sys_prompts[-1],
-                      "confirm block not injected into the system prompt")
-        # Turn 2: user confirms.
-        r2 = _run(single_brain.handle_turn(sess, "yes, that's me"))
-        self.assertTrue(r2.returning_user_recalled,
-                        "explicit 'yes' must flip returning_user_recalled")
-        self.assertEqual(sess.profile.age, 41,
-                         "stored profile was not merged on confirm")
-        self.assertIsNone(getattr(sess, "pending_profile_recall", None))
-        # The apply turn MUST carry the PROFILE RESTORED directive so the
-        # model does not re-ask the just-recalled slots (the live bug:
-        # recall merged but turn-2 still asked income + pre-existing).
-        self.assertIn("RETURNING USER CONFIRMED — PROFILE RESTORED",
-                      self.sys_prompts[-1])
-        self.assertIn("Re-asking a RESTORED slot is a hard error",
-                      self.sys_prompts[-1])
-
-    def test_no_keeps_session_blank(self):
-        sess = SessionState(session_id=f"hti_{uuid.uuid4().hex[:8]}")
-        _run(single_brain.handle_turn(sess, f"Hello, I am {self.name}"))
-        self.assertTrue(sess.pending_profile_recall)
-        r2 = _run(single_brain.handle_turn(sess, "no, I'm a new user"))
-        self.assertFalse(r2.returning_user_recalled)
-        self.assertIn(getattr(sess.profile, "age", None), (None, "", 0))
-        self.assertIsNone(sess.pending_profile_recall)
-
-    def test_unknown_name_normal_flow(self):
-        sess = SessionState(session_id=f"hti_{uuid.uuid4().hex[:8]}")
-        r1 = _run(single_brain.handle_turn(
-            sess, "Hi, I'm Zzqxnobodyhasthisname"))
-        self.assertIsNone(getattr(sess, "pending_profile_recall", None))
-        self.assertFalse(r1.returning_user_recalled)
-        self.assertNotIn("RETURNING-USER CHECK", self.sys_prompts[-1])
-
-
-if __name__ == "__main__":
-    unittest.main()

tests/test_session_no_disk_persistence.py

@@ -9,10 +9,10 @@ side was:
   2. A privacy and operational liability (orphan files accumulate, schema
      drift hits old files, cross-session memory leak surface).
 
-KI-118 rip-out: session_state is in-memory only. Cross-session memory is
-strictly name-based (returning user provides their name → fact_find brain
-captures it → `rehydrate_by_name` pulls the named profile from
-`40-data/profiles/`).
+KI-118 rip-out: session_state is in-memory only. ADR-043 (2026-05-27)
+went further and removed the cross-session name-keyed recall too, so
+there is now no on-disk profile store of any kind — `40-data/profiles/`
+is gone.
 
 This test pins the contract: a session lifecycle (get, mutate, set_awaiting,
 record_answer, update_profile_field, reset) MUST NOT create ANY file under