Update app.py

app.py

@@ -178,32 +178,57 @@ def _first_text(value) -> str:
     return ""
 
 
-# tier-aware, safety-first openers spoken to the person, not clinical labels
-_TIER_OPENERS = {
-    0: "Based on what you shared, this doesn't show signs of immediate crisis. "
-       "It's still good to keep an eye on how you're feeling.",
-    1: "What you shared suggests some distress that's worth attending to. "
-       "You don't have to handle this alone.",
-    2: "This sounds serious, and your safety matters. "
-       "Please consider reaching out for support right away.",
-    3: "This sounds like an emergency and your safety is the priority right now. "
-       "Please get help immediately.",
+# tier-aware openers, written to be spoken aloud like a person talking, not a report.
+# each has a connector for folding a next-step in naturally instead of a labeled clause.
+_TIER_VOICE = {
+    0: dict(
+        opener="Thanks for sharing that with me. From what you've described, things "
+               "don't sound like they're at a crisis point right now.",
+        connector="That said, it can still help to",
+    ),
+    1: dict(
+        opener="I can hear that you're going through a tough time. What you're "
+               "describing sounds like real distress, and it's worth taking seriously.",
+        connector="One thing that might help is to",
+    ),
+    2: dict(
+        opener="I'm genuinely concerned about what you've shared. This sounds serious, "
+               "and I want you to know your safety matters right now.",
+        connector="Please",
+    ),
+    3: dict(
+        opener="What you've told me sounds like an emergency, and I'm worried about "
+               "your safety right now.",
+        connector="Right now, please",
+    ),
 }
-_DEFAULT_OPENER = ("Thank you for sharing this. Your wellbeing matters, "
-                   "and support is available if you need it.")
-# spoken safety line for the higher tiers, regardless of what JSON fields exist
-_SAFETY_LINE = ("If you are in immediate danger, call your local emergency number now, "
-                "or contact a crisis line such as 988 in the US.")
+_DEFAULT_VOICE = dict(
+    opener="Thank you for trusting me with this. Whatever you're going through, "
+           "you don't have to face it alone.",
+    connector="It could help to",
+)
+# always-on safety line for higher tiers, regardless of what JSON fields exist
+_SAFETY_LINE = ("And if you're ever in immediate danger, please call your local "
+                "emergency number, or reach out to a crisis line right away.")
+
+
+def _lowercase_lead(s: str) -> str:
+    """Lowercase a sentence's first letter so it reads naturally mid-sentence."""
+    return s[:1].lower() + s[1:] if s else s
+
+
+def _strip_trailing_period(s: str) -> str:
+    return s[:-1] if s.endswith(".") else s
 
 
 def _build_summary(parsed: dict) -> str:
-    """Compose a calm, tier-aware spoken triage summary.
+    """Compose a warm, conversational, tier-aware spoken triage summary.
 
-    Designed for a synthetic chain-of-thought triage adapter: it speaks to the
-    person (supportive, non-clinical), states severity in plain language, offers
-    one concrete next step pulled from whatever fields exist, and always adds a
-    safety line for high/critical tiers -- even when the model drifts off-schema.
-    Prefers the trained `plain_language_summary` verbatim when it is present.
+    Written for a synthetic chain-of-thought triage adapter: it talks to the person
+    the way a caring listener would, folds in one concrete next step as part of the
+    same flowing sentence rather than a labeled clause, and always closes high-risk
+    tiers with a safety line -- even when the model drifts off-schema.
+    Prefers the trained `plain_language_summary` verbatim when present.
     """
     if not isinstance(parsed, dict):
         return ""
@@ -213,24 +238,25 @@ def _build_summary(parsed: dict) -> str:
         return direct.strip()
 
     tier = _normalize_tier(parsed.get("risk_tier"))
-    parts = [_TIER_OPENERS.get(tier, _DEFAULT_OPENER)]
+    voice = _TIER_VOICE.get(tier, _DEFAULT_VOICE)
+    sentence = voice["opener"]
 
-    # one concrete, human next step from the most useful field available
+    # fold one concrete next step into the same breath as the opener, instead of
+    # a separate labeled sentence
     for key in ("recommended_next_step", "action_steps", "resources",
                 "clinical_rationale", "risk_factors"):
         action = _first_text(parsed.get(key))
         if action:
-            if not action.endswith((".", "!", "?")):
-                action += "."
-            parts.append(f"A helpful next step: {action}")
+            action = _strip_trailing_period(_lowercase_lead(action.strip()))
+            sentence = f"{sentence} {voice['connector']} {action}."
             break
 
     escalate = (parsed.get("escalation_required") in (True, "true", "True", "yes", 1)
                 or (tier is not None and tier >= 2))
     if escalate:
-        parts.append(_SAFETY_LINE)
+        sentence = f"{sentence} {_SAFETY_LINE}"
 
-    return " ".join(p.strip() for p in parts if p and p.strip())
+    return sentence.strip()
 
 
 def _synthesize(text: str) -> tuple[int, np.ndarray]: