[agentic] LLM labeled review summary, eligibility-aware assessment, control fix

- Interview review step is now an LLM step: a warm, labelled summary in the
person's language (country of origin: …, current country: …, what happened: …,
etc.), not plain bullets; deterministic labelled fallback if the model is down.
- Assessment reasons honestly about case type (refugee / broader protection /
statelessness / economic_or_other / unclear) instead of assuming everyone is a
Convention refugee — e.g. it won't push UNHCR asylum at a clearly economic or
stateless case. case_type parsed + stored on session.assessment.
- Fixed the "control only appears after pressing Continue" lag by pre-mounting
the choice controls with choices (Gradio lags updating choices on a freshly
revealed component).

64 fast tests pass.

Co-authored-by: Codex <noreply@openai.com>

app/assessment_parse.py

@@ -21,6 +21,7 @@ class AssessmentResult:
     grounds: list[str] = field(default_factory=list)
     risk: str | None = None
     countries: list[str] = field(default_factory=list)
+    case_type: str | None = None
 
 
 def _split_list(value: str) -> list[str]:
@@ -67,6 +68,8 @@ def parse_assessment(text: str) -> tuple[str, AssessmentResult]:
             result.risk = risk if risk in _VALID_RISK else None
         elif key == "countries":
             result.countries = _split_list(value)
+        elif key == "case_type":
+            result.case_type = value.lower().replace(" ", "_") or None
 
     return visible, result
 

app/phases/assessment.py

@@ -236,6 +236,7 @@ async def stream_assessment(session: SessionState, loop):
 
     session.assessment.convention_grounds = result.grounds
     session.assessment.risk_level = result.risk
+    session.assessment.case_type = result.case_type
     session.assessment.reasoning_trace = visible
     session.assessment.recommended_countries = recs
     advance_to(session, State.RECOMMENDATIONS)

app/phases/interview.py

@@ -14,8 +14,10 @@ import html
 
 import gradio as gr
 
+from agent.events import TextDeltaEvent
 from agent.loop import create_loop
 from app.countries import country_choices, country_name
+from app.prompt_loader import load_prompt
 from app.interview_script import (
     QUESTIONS,
     REVIEW_INDEX,
@@ -206,15 +208,54 @@ def _facts_recap(session: SessionState) -> str:
 
 
 def _agent_message_for(session: SessionState, idx: int, *, welcome: bool = False) -> str:
-    lang = session.language
-    if idx >= REVIEW_INDEX:
-        return f"{t(lang, 'review_intro')}\n{_facts_recap(session)}\n\n{t(lang, 'review_confirm')}"
-    text = question_text(lang, QUESTIONS[idx], session)
+    text = question_text(session.language, QUESTIONS[idx], session)
     if welcome:
-        return f"{t(lang, 'welcome')}\n{text}"
+        return f"{t(session.language, 'welcome')}\n{text}"
     return text
 
 
+def _labeled_facts(session: SessionState) -> str:
+    iv = session.interview
+    fields = [
+        ("Country of origin", iv.origin_country),
+        ("Current country", iv.current_country),
+        ("What happened", iv.free_text_history),
+        ("Immediate danger", None if iv.immediate_danger is None else ("yes" if iv.immediate_danger else "no")),
+        ("Time since leaving", iv.displacement_duration),
+        ("Documents", ", ".join(iv.documents_available) if iv.documents_available else None),
+        ("Languages", ", ".join(iv.languages_spoken) if iv.languages_spoken else None),
+        ("Preferred destination", ", ".join(iv.destination_preferences) if iv.destination_preferences else None),
+    ]
+    return "\n".join(f"{k}: {v}" for k, v in fields if v)
+
+
+def _labeled_fallback(session: SessionState) -> str:
+    lang = session.language
+    return f"{t(lang, 'review_intro')}\n{_labeled_facts(session)}\n\n{t(lang, 'review_confirm')}"
+
+
+async def _draft_review(session: SessionState, loop) -> str:
+    """LLM-written labeled review summary in the person's language."""
+    lang = session.language or "English"
+    system_prompt = (
+        load_prompt("system")
+        + f"\n\n# Right now\nIn {lang}, briefly summarise back what the person told you so they "
+        "can confirm. State each item on its own line, clearly labelled (country of origin, "
+        "current country, what happened, immediate danger, time since leaving, documents, "
+        "languages, preferred destination). Use ONLY the facts given — do not invent or omit. "
+        "End by asking, in one short sentence, whether it is correct."
+    )
+    acc = ""
+    try:
+        async for ev in loop.run("Facts:\n" + _labeled_facts(session), session=None,
+                                 system_prompt=system_prompt, thinking_level="off"):
+            if isinstance(ev, TextDeltaEvent):
+                acc += ev.delta
+    except Exception:
+        acc = ""
+    return acc.strip() or _labeled_fallback(session)
+
+
 # --------------------------------------------------------------------------
 # UI assembly
 # --------------------------------------------------------------------------
@@ -235,8 +276,13 @@ def build(visible: bool = True, session_st=None, loop_st=None, slot_idx_st=None)
             chat = gr.HTML(render_chat([]))
             with gr.Column(elem_id="iv-responder"):
                 lbl = gr.HTML('<div class="label-row">Your answer</div>')
-                radio = gr.Radio(choices=[], label="", show_label=False, visible=False, elem_id="iv-choice")
-                multi = gr.CheckboxGroup(choices=[], label="", show_label=False, visible=False, elem_id="iv-multi")
+                # Pre-mount with choices so they render immediately when shown
+                # (Gradio is laggy updating choices on a freshly-revealed control).
+                radio = gr.Radio(choices=["Yes", "No"], label="", show_label=False, visible=False, elem_id="iv-choice")
+                multi = gr.CheckboxGroup(
+                    choices=[t("English", oid) for q in QUESTIONS if q.control == "choice" for oid in q.options],
+                    label="", show_label=False, visible=False, elem_id="iv-multi",
+                )
                 country = gr.Dropdown(choices=country_choices(), label="", show_label=False, visible=False,
                                       allow_custom_value=True, filterable=True, elem_id="iv-country")
                 text = gr.Textbox(label="", show_label=False, lines=3, visible=False,
@@ -245,11 +291,15 @@ def build(visible: bool = True, session_st=None, loop_st=None, slot_idx_st=None)
 
     stream_outputs = [chat, rail, radio, multi, country, text, session_st, loop_st, slot_idx_st]
 
-    def _present(session, idx):
-        """Append the agent's (scripted) message and show its control."""
+    async def _present(session, loop, idx):
+        """Append the agent's message (scripted question, or LLM review summary)
+        and show the right control for the step."""
         target = State.REVIEW if idx >= REVIEW_INDEX else QUESTIONS[idx].phase
         advance_to(session, target)
-        msg = _agent_message_for(session, idx, welcome=(idx == 0))
+        if idx >= REVIEW_INDEX:
+            msg = await _draft_review(session, loop)
+        else:
+            msg = _agent_message_for(session, idx, welcome=(idx == 0))
         session.messages = list(session.messages) + [{"role": "assistant", "content": msg}]
         return (render_chat(session.messages), render_rail(session.state),
                 *control_updates(session, idx), session, idx)
@@ -258,18 +308,18 @@ def build(visible: bool = True, session_st=None, loop_st=None, slot_idx_st=None)
         if session is None:
             session = SessionState(); session.transition_to(State.INTAKE)
         loop = loop or create_loop()
-        out = _present(session, 0)
-        # yield (chat, rail, radio, multi, country, text, session, loop, idx)
+        out = await _present(session, loop, 0)
         yield (out[0], out[1], out[2], out[3], out[4], out[5], out[6], loop, out[7])
 
-    def on_continue(radio_v, multi_v, country_v, text_v, session, loop, idx):
+    async def on_continue(radio_v, multi_v, country_v, text_v, session, loop, idx):
         if session is None:
             session = SessionState(); session.transition_to(State.INTAKE)
-            o = _present(session, 0)
-            return (o[0], o[1], o[2], o[3], o[4], o[5], o[6], loop or create_loop(), o[7])
-
+            loop = loop or create_loop()
+            o = await _present(session, loop, 0)
+            return (o[0], o[1], o[2], o[3], o[4], o[5], o[6], loop, o[7])
+        loop = loop or create_loop()
         lang = session.language
-        # Review step
+
         if idx >= REVIEW_INDEX:
             if not radio_v:
                 return (gr.update(), gr.update(), *control_updates(session, idx), session, loop, idx)
@@ -279,8 +329,7 @@ def build(visible: bool = True, session_st=None, loop_st=None, slot_idx_st=None)
                 return (render_chat(session.messages), render_rail(session.state),
                         gr.update(visible=False), gr.update(visible=False),
                         gr.update(visible=False), gr.update(visible=False), session, loop, idx)
-            # "something needs changing" → start the questions over
-            o = _present(session, 0)
+            o = await _present(session, loop, 0)  # "something needs changing" → restart
             return (o[0], o[1], o[2], o[3], o[4], o[5], o[6], loop, o[7])
 
         q = QUESTIONS[idx]
@@ -288,7 +337,7 @@ def build(visible: bool = True, session_st=None, loop_st=None, slot_idx_st=None)
         if display is None:
             return (gr.update(), gr.update(), *control_updates(session, idx), session, loop, idx)
         session.messages = list(session.messages) + [{"role": "user", "content": display}]
-        o = _present(session, idx + 1)
+        o = await _present(session, loop, idx + 1)
         return (o[0], o[1], o[2], o[3], o[4], o[5], o[6], loop, o[7])
 
     continue_event = cont.click(

app/prompts/assessment.md

@@ -5,12 +5,25 @@ plain, calm language, as if thinking a case through on paper — not hidden behi
 spinner, and not as raw JSON. Write it so the person can follow why you reach your
 recommendation. Address them as "you".
 
-Work through these steps in order, narrating each briefly:
+Work through these steps in order, narrating each briefly. **Be honest about
+eligibility — do not assume every person is a Convention refugee.**
 
-1. **1951 Refugee Convention.** Consider whether the person's situation fits the
-   Convention grounds — persecution for reasons of race, religion, nationality,
-   membership of a particular social group, or political opinion. Say which
-   ground(s) appear to apply, and why, in one or two plain sentences.
+1. **What kind of case is this?** First decide, from what the person told you,
+   which situation best fits — and say so plainly:
+   - **Refugee (1951 Convention):** a real risk of persecution on grounds of
+     race, religion, nationality, political opinion, or membership of a
+     particular social group. Name the ground(s) that apply.
+   - **Broader protection (1969 AU Convention):** fleeing war, occupation, or
+     events seriously disturbing public order.
+   - **Statelessness:** the person has no nationality (e.g. born somewhere that
+     gave no citizenship, parents from elsewhere). This is a protection issue —
+     point to statelessness determination procedures and UNHCR's statelessness
+     mandate, not ordinary refugee asylum.
+   - **Mainly economic / other migration:** if there is no protection ground,
+     say so honestly and kindly. Do **not** pretend it is a strong asylum claim.
+     Point to realistic alternatives (regular migration/work routes, consular
+     help, legal advice) instead of UNHCR asylum.
+   If you are unsure, say what is unclear and what would change the assessment.
 2. **1969 AU (OAU) Refugee Convention.** For people in Africa, this is broader —
    it also covers those fleeing external aggression, occupation, foreign
    domination, or events seriously disturbing public order. Note if it applies.
@@ -41,14 +54,18 @@ After your narrated reasoning, end your message with **exactly one** structured
 block, on its own lines, so the interface can build the recommendation cards:
 
     @@ASSESSMENT
-    grounds: <convention ground(s), pipe-separated>
+    case_type: <refugee | broader_protection | statelessness | economic_or_other | unclear>
+    grounds: <convention ground(s) or basis, pipe-separated>
     risk: <high | moderate | low>
     countries: <Country A | Country B | Country C>
     @@END
 
 Rules:
-- `countries` are your ranked destination recommendations (2–3), by name, best
-  first. Never include the person's country of origin.
+- `case_type` is your honest read of what kind of case this is (step 1).
+- `countries` are realistic destination recommendations (2–3), best first, that
+  fit `case_type`. Never include the person's country of origin. If the case is
+  `economic_or_other` and no protection applies, you may give fewer countries (or
+  none) and rely on your narrated honest guidance instead.
 - `risk` is your overall read of the danger the person faces.
 - Write nothing after the `@@END` line. The person never sees this block — it is
   metadata for the interface.

app/state/session.py

@@ -71,6 +71,7 @@ class Interview:
 class Assessment:
     convention_grounds: list[str] = field(default_factory=list)
     risk_level: Optional[str] = None  # "high" | "moderate" | "low"
+    case_type: Optional[str] = None   # refugee | broader_protection | statelessness | economic_or_other | unclear
     reasoning_trace: str = ""
     recommended_countries: list[dict] = field(default_factory=list)