fix(ux): cold-start retries + retry-intent handling + insurer-prefixed citations

Three bugs visible in the 2026-05-14 mobile screenshot:

Bug A — "Sorry — backend error: Load failed"
HF Space cold-starts after ~15min idle take ~50s; Safari's fetch surfaces
this as a generic TypeError. Fix: api.ts adds _fetchWithRetry with
exponential backoff (1.5s, 3.5s, 7s). 502/503 and network errors retry
up to 3x; AbortError (Live-mode barge-in) is NOT retried. onRetry
callback surfaces "Connection slow — retrying…" status. Final chat
message on failure now suggests "say 'try again'" instead of "Load failed".

Bug B — "Sarvah Param" rendered as unattributed citation
ManipalCigna Sarvah-Param is a real policy; chip showed only policy_name.
Fix: PolicyChipsFromCitations renders insurer_slug as kicker above the
name. "MANIPALCIGNA / Sarvah Param" — clear provenance, mobile-friendly.

Bug C — "Try again" got refused by Gate 1
"Try again" has no policy context so retrieval found nothing → Gate 1
refused. Fix: page.tsx tracks lastSubmittedTextRef and _isRetryIntent()
matches English + Hinglish retry phrases ("try again", "retry", "say it
again", "ek baar aur", "phir se"). On detect, send() resubmits the
previous user_text with a "Retrying: …" acknowledgment.

AbortError silently drops the catch (Live-mode barge-in is intentional).

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

frontend/src/app/page.tsx

@@ -189,11 +189,40 @@ export default function Page() {
     setMessages((m) => [...m, { id: `a_${Date.now()}`, role: "assistant", content, ...extras }]);
   }
 
+  // Last user message that actually went to the LLM (post retry-detection).
+  // Used to resolve "try again" / "retry" intent back to the original turn.
+  const lastSubmittedTextRef = useRef<string>("");
+
+  // Phrases that mean "resend my previous turn", not "answer this literally".
+  function _isRetryIntent(text: string): boolean {
+    const s = text.toLowerCase().trim().replace(/[.!?,]+$/, "");
+    return [
+      "try again", "try that again", "retry", "retry that",
+      "say it again", "say that again", "once more", "one more time",
+      "repeat", "repeat that", "ek baar aur", "phir se",
+    ].includes(s);
+  }
+
   async function send(text: string) {
     if (!text.trim() || busy) return;
     setBusy(true);
     setInput("");
-    pushUser(text);
+
+    // Bug C — if the user is asking us to retry, resubmit the previous user
+    // turn (the one that actually had policy / fact-find context) instead of
+    // hitting Gate-1 with no retrieval.
+    let actualText = text;
+    if (_isRetryIntent(text) && lastSubmittedTextRef.current) {
+      actualText = lastSubmittedTextRef.current;
+      // Show the user we understood the retry — surface a system note instead
+      // of echoing "try again" back through retrieval.
+      pushUser(text);
+      pushAssistant(`Retrying: "${actualText}"`, {});
+    } else {
+      pushUser(text);
+    }
+    lastSubmittedTextRef.current = actualText;
+
     try {
       const history: ChatMessage[] = messages.map((m) => ({ role: m.role, content: m.content }));
       // Real-time copilot context — tells the backend what the user is
@@ -206,7 +235,7 @@ export default function Page() {
         showPremium ? "premium" :
         "chat";
       const res = await postChat({
-        user_text: text,
+        user_text: actualText,
         session_id: sessionId,
         chat_history: history,
         return_audio: returnAudio,
@@ -215,7 +244,18 @@ export default function Page() {
           active_view,
           active_policy_id: openPolicy?.policy_id,
         },
+        onRetry: (attempt) => {
+          // Show transient "warming up" hint while postChat retries the
+          // cold-started Space behind the scenes. Don't push as a message;
+          // use the input area's status string so it doesn't clutter chat.
+          setUploadStatus(
+            attempt === 1
+              ? "Connection slow — retrying…"
+              : `Still warming up (attempt ${attempt} of 3)…`,
+          );
+        },
       });
+      setUploadStatus(null);
       setSessionId(res.session_id);
       // Refresh profileCompleteness after every chat turn so that any profile
       // fields the backend extracted from the user's message (age, conditions,
@@ -254,8 +294,25 @@ export default function Page() {
         setTimeout(() => { if (handsFreeRef.current) startRecording(); }, 500);
       }
     } catch (e: unknown) {
-      pushAssistant(`Sorry — backend error: ${e instanceof Error ? e.message : String(e)}`);
+      const err = e as { name?: string; message?: string };
+      if (err?.name === "AbortError") {
+        // Live-mode barge-in cancelled this turn intentionally; stay silent.
+        return;
+      }
+      const msg = err?.message || String(e);
+      // Bug A — friendlier message for the cold-start / network failure case
+      // that Safari surfaces as "Load failed". Suggest the retry-intent path
+      // so the user doesn't lose their actual question.
+      if (/Load failed|Failed to fetch|NetworkError|chat failed: 5\d\d/i.test(msg)) {
+        pushAssistant(
+          `Connection hiccup — the bot may have been sleeping (HF Space cold-start). ` +
+          `Say "try again" or tap Send again and I'll re-run your last question.`,
+        );
+      } else {
+        pushAssistant(`Sorry — backend error: ${msg}`);
+      }
     } finally {
+      setUploadStatus(null);
       setBusy(false);
     }
   }
@@ -1257,7 +1314,17 @@ function PolicyChipsFromCitations({ citations }: { citations: Citation[] }) {
                 title={sc?.one_liner || c.policy_name}
               >
                 {sc && <span className={`inline-flex items-center justify-center w-5 h-5 rounded font-bold text-[11px] ${gradeColor(sc.grade)}`}>{sc.grade}</span>}
-                <span className="font-medium truncate max-w-[140px]">{c.policy_name}</span>
+                <span className="flex flex-col items-start leading-tight">
+                  {/* Bug B — show the insurer label above the policy name so
+                      "Sarvah Param" reads as "ManipalCigna · Sarvah Param"
+                      instead of an unattributed policy fragment. */}
+                  {c.insurer_slug && (
+                    <span className="text-[9px] uppercase tracking-wider text-[var(--muted-foreground)]">
+                      {c.insurer_slug.replace(/-/g, " ")}
+                    </span>
+                  )}
+                  <span className="font-medium truncate max-w-[160px]">{c.policy_name}</span>
+                </span>
               </button>
               {c.source_url && (
                 <a

frontend/src/lib/api.ts

@@ -47,6 +47,44 @@ export type ViewContext = {
   filters?: Record<string, unknown>;
 };
 
+/** HF Space's first request after ~15min idle takes ~50s for cold-start.
+ *  Add retry-with-backoff so a single "Load failed" doesn't surface as an
+ *  error in the chat — instead we wait and try again silently. AbortError
+ *  is NOT retried (it's intentional cancellation from Live mode's barge-in).
+ */
+async function _fetchWithRetry(
+  url: string,
+  init: RequestInit,
+  signal: AbortSignal | undefined,
+  onRetry?: (attempt: number) => void,
+): Promise<Response> {
+  const retryDelaysMs = [1500, 3500, 7000];
+  let lastErr: unknown = null;
+  for (let attempt = 0; attempt <= retryDelaysMs.length; attempt++) {
+    if (signal?.aborted) throw new DOMException("aborted", "AbortError");
+    try {
+      const resp = await fetch(url, { ...init, signal });
+      if (resp.status >= 500 && attempt < retryDelaysMs.length) {
+        // 502/503 commonly means HF Space cold-start; retry
+        await new Promise((r) => setTimeout(r, retryDelaysMs[attempt]));
+        onRetry?.(attempt + 1);
+        continue;
+      }
+      return resp;
+    } catch (e) {
+      const name = (e as { name?: string })?.name;
+      if (name === "AbortError") throw e;
+      lastErr = e;
+      if (attempt < retryDelaysMs.length) {
+        await new Promise((r) => setTimeout(r, retryDelaysMs[attempt]));
+        onRetry?.(attempt + 1);
+        continue;
+      }
+    }
+  }
+  throw lastErr ?? new Error("network failed after retries");
+}
+
 export async function postChat(args: {
   user_text: string;
   session_id?: string;
@@ -57,22 +95,27 @@ export async function postChat(args: {
   tts_language_code?: string;
   view_context?: ViewContext;
   signal?: AbortSignal;
+  onRetry?: (attempt: number) => void;
 }): Promise<ChatResponse> {
-  const resp = await fetch(`${BACKEND_URL}/api/chat`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      user_text: args.user_text,
-      session_id: args.session_id,
-      chat_history: args.chat_history ?? [],
-      profile: args.profile ?? {},
-      policy_filter_ids: args.policy_filter_ids,
-      return_audio: args.return_audio ?? false,
-      tts_language_code: args.tts_language_code ?? "en-IN",
-      view_context: args.view_context,
-    }),
-    signal: args.signal,
-  });
+  const resp = await _fetchWithRetry(
+    `${BACKEND_URL}/api/chat`,
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        user_text: args.user_text,
+        session_id: args.session_id,
+        chat_history: args.chat_history ?? [],
+        profile: args.profile ?? {},
+        policy_filter_ids: args.policy_filter_ids,
+        return_audio: args.return_audio ?? false,
+        tts_language_code: args.tts_language_code ?? "en-IN",
+        view_context: args.view_context,
+      }),
+    },
+    args.signal,
+    args.onRetry,
+  );
   if (!resp.ok) {
     const t = await resp.text();
     throw new Error(`chat failed: ${resp.status} ${t}`);