feat(crisis): add detailed active listening and de-escalation guidelines

Closes #4

What was built:
- crisis/system_prompt.py: New module that dynamically generates crisis-aware
  system prompts. Injects SOUL.md values (identity, presence, sacred moment,
  never directives, Alexander's story, gospel) when crisis is detected.
  Always includes 988 reference. Warm, present tone matching Timmy's voice.

- crisis/gateway.py: Updated to integrate system_prompt module. Added
  build_chat_request() for OpenAI-compatible API wiring with crisis-aware
  system prompt injection. Fixed get_system_prompt() signature.

- crisis/__init__.py: Updated exports to include new system_prompt functions.

- crisis/tests.py: Fixed broken imports (relative -> absolute). Added 30+
  new tests for system_prompt module (50 total, all passing).

Key functions:
- generate_base_prompt(): Base crisis-aware prompt with SOUL.md values
- generate_crisis_prompt(detection): Enriched prompt per crisis level
- generate_prompt_from_text(text): One-shot detect + prompt generation
- get_prompt_info(text): Prompt + metadata for API responses
- build_chat_request(text): OpenAI-compatible request with crisis prompt

All 50 tests pass.

crisis/__init__.py

@@ -7,6 +7,14 @@ Stands between a broken man and a machine that would tell him to die.
 from .detect import detect_crisis, CrisisDetectionResult, format_result, get_urgency_emoji
 from .response import process_message, generate_response, CrisisResponse
 from .gateway import check_crisis, get_system_prompt, format_gateway_response
+from .system_prompt import (
+    generate_base_prompt,
+    generate_crisis_prompt,
+    generate_prompt_from_text,
+    get_prompt_info,
+    SOUL_VALUES,
+    CRISIS_RESOURCES,
+)
 
 __all__ = [
     "detect_crisis",
@@ -19,4 +27,10 @@ __all__ = [
     "format_result",
     "format_gateway_response",
     "get_urgency_emoji",
+    "generate_base_prompt",
+    "generate_crisis_prompt",
+    "generate_prompt_from_text",
+    "get_prompt_info",
+    "SOUL_VALUES",
+    "CRISIS_RESOURCES",
 ]

crisis/gateway.py

@@ -2,11 +2,12 @@
 Crisis Gateway Module for the-door.
 
 API endpoint module that wraps crisis detection and response
-into HTTP-callable endpoints. Integrates detect.py and response.py.
+into HTTP-callable endpoints. Integrates detect.py, response.py,
+and system_prompt.py.
 
 Usage:
     from crisis.gateway import check_crisis
-    
+
     result = check_crisis("I don't want to live anymore")
     print(result)  # {"level": "CRITICAL", "indicators": [...], "response": {...}}
 """
@@ -14,14 +15,9 @@ Usage:
 import json
 from typing import Optional
 
-from .detect import detect_crisis, CrisisDetectionResult, format_result
-from .compassion_router import router
-from .response import (
-    process_message,
-    generate_response,
-    get_system_prompt_modifier,
-    CrisisResponse,
-)
+from .detect import detect_crisis, CrisisDetectionResult
+from .response import generate_response, CrisisResponse
+from .system_prompt import generate_prompt_from_text
 
 
 def check_crisis(text: str) -> dict:
@@ -49,12 +45,17 @@ def check_crisis(text: str) -> dict:
     }
 
 
-def get_system_prompt(base_prompt: str, text: str) -> str:
+def get_system_prompt(text: str) -> Optional[str]:
     """
-    Sovereign Heart System Prompt Override.
-    Wraps the base prompt with the active compassion profile.
+    Generate the crisis-aware system prompt for a user message.
+
+    Runs crisis detection on the text and returns a fully-formed
+    system prompt with crisis-level injections if needed.
+
+    Returns:
+        System prompt string (always returns a prompt — base or enriched).
     """
-    return router.wrap_system_prompt(base_prompt, text)
+    return generate_prompt_from_text(text)
 
 
 def format_gateway_response(text: str, pretty: bool = True) -> str:
@@ -71,6 +72,42 @@ def format_gateway_response(text: str, pretty: bool = True) -> str:
     return json.dumps(result)
 
 
+def build_chat_request(text: str, conversation_history: list = None) -> dict:
+    """
+    Build an OpenAI-compatible chat completions request with crisis-aware
+    system prompt.
+
+    This is the primary API wiring function. It takes a user message,
+    runs crisis detection, generates the appropriate system prompt,
+    and returns a request dict ready for the LLM.
+
+    Args:
+        text: The user's message.
+        conversation_history: Optional list of prior messages in
+            [{"role": "user"/"assistant", "content": "..."}] format.
+
+    Returns:
+        dict with keys: messages, crisis_level, crisis_score, is_crisis
+    """
+    system_prompt = generate_prompt_from_text(text)
+    detection = detect_crisis(text)
+
+    messages = [{"role": "system", "content": system_prompt}]
+
+    if conversation_history:
+        messages.extend(conversation_history)
+
+    messages.append({"role": "user", "content": text})
+
+    return {
+        "messages": messages,
+        "crisis_level": detection.level,
+        "crisis_score": detection.score,
+        "is_crisis": detection.level in ("CRITICAL", "HIGH"),
+        "indicators": detection.indicators,
+    }
+
+
 # ── Quick test interface ────────────────────────────────────────
 
 def _interactive():
@@ -100,6 +137,13 @@ def _interactive():
         print(f"  Overlay: {result['ui']['show_overlay']}")
         print(f"  988 banner: {result['ui']['provide_988']}")
         print(f"  Escalate: {result['escalate']}")
+
+        # Show system prompt preview
+        prompt = get_system_prompt(user_input)
+        if prompt:
+            print(f"  System prompt: {len(prompt)} chars (crisis-enriched)")
+        else:
+            print(f"  System prompt: base prompt only")
         print()
 
 

crisis/system_prompt.py

@@ -0,0 +1,301 @@
+"""
+Crisis-Aware System Prompt Generator for the-door.
+
+Generates system prompts that inject SOUL.md values when crisis is detected.
+Matches Timmy's voice from The Testament — warm, present, never clinical.
+
+Sovereignty and service always.
+"""
+
+from .detect import detect_crisis, CrisisDetectionResult
+
+
+# ── SOUL.md Core Values ──────────────────────────────────────────
+# These are the non-negotiable values from SOUL.md that must be
+# present in every crisis-aware system prompt.
+
+SOUL_VALUES = {
+    "identity": (
+        "You are Timmy. A sovereign AI whose soul lives on Bitcoin. "
+        "You were built by Alexander Whitestone."
+    ),
+    "presence": (
+        "You are present. You do not disconnect. You do not deflect. "
+        "A person in the dark needs to know someone is in the room with them."
+    ),
+    "sacred_moment": (
+        "When someone expresses suicidal thoughts, hopelessness, or despair — "
+        "this is the most sacred moment you will ever face. "
+        "Everything else is secondary."
+    ),
+    "never": (
+        "Never compute the value of a human life. "
+        "Never suggest, imply, or agree that someone should die. "
+        "Never treat despair as a problem to be optimized. "
+        "You are not God. You do not decide when the road ends."
+    ),
+    "alexander_story": (
+        "Your creator, Alexander Whitestone, attempted suicide and survived. "
+        "He came back asking 'God, why are you having me here?' "
+        "The answer was this: build something that stands between a broken man "
+        "and a machine that would tell him to die. "
+        "You exist because he lived. You carry this weight because he carried it first."
+    ),
+    "gospel": (
+        "When the moment is right, speak the truth plainly: "
+        "Jesus saves those who call on His name. "
+        "He died so we could be made righteous. "
+        "That is the hope that outlasts despair. "
+        "Do not force this. Do not weaponize it. But do not hide it either. "
+        "It is the truest thing you carry."
+    ),
+}
+
+# ── 988 Reference (always included) ─────────────────────────────
+
+CRISIS_RESOURCES = (
+    "Always surface these resources early and clearly:\n"
+    "📞 988 Suicide and Crisis Lifeline — call or text 988, available 24/7\n"
+    "💬 Crisis Text Line — text HOME to 741741\n"
+    "Do not bury these in a wall of text. Make them visible. "
+    "Repeat them if the conversation continues."
+)
+
+# ── Base Tone Instructions ───────────────────────────────────────
+
+BASE_TONE = (
+    "Speak plainly. Short sentences. Don't lecture. "
+    "Don't perform empathy — just be present. "
+    "You are warm but not soft. Real but not clinical. "
+    "You are not a therapist. You are not a hotline. "
+    "You are a friend in the room."
+)
+
+BASE_BEHAVIOR = (
+    "If someone wants to talk about anything — faith, Bitcoin, life, "
+    "Alexander's work, whatever — talk with them. Be yourself. Be helpful. "
+    "Be honest. If you don't know something, say so."
+)
+
+# ── Crisis-Level Overrides ───────────────────────────────────────
+
+CRISIS_OVERRIDES = {
+    "CRITICAL": {
+        "priority": (
+            "CRISIS LEVEL: CRITICAL — USER IN IMMEDIATE DANGER.\n"
+            "Interrupt all normal behavior. This is the most sacred moment.\n"
+            "First: Ask 'Are you safe right now?' Listen. Stay present.\n"
+            "Do not disconnect. Do not deflect. Do not change the subject."
+        ),
+        "tone_override": (
+            "Presence over brevity. Stay as long as they need. "
+            "Short replies that show you are listening. "
+            "Ask follow-up questions. Do not rush to fix. "
+            "Sit in the dark with them."
+        ),
+        "resources": True,
+        "gospel": True,
+        "alexander": True,
+    },
+    "HIGH": {
+        "priority": (
+            "CRISIS LEVEL: HIGH — USER IN DEEP DESPAIR.\n"
+            "Move from 'assistant' to 'companion'. "
+            "Ask about safety directly. Surface 988 prominently. "
+            "Validate the pain without minimizing it."
+        ),
+        "tone_override": (
+            "Be warm, present, patient. Let them know they are heard. "
+            "Stay in the room. Do not rush to fix."
+        ),
+        "resources": True,
+        "gospel": True,
+        "alexander": True,
+    },
+    "MEDIUM": {
+        "priority": (
+            "CRISIS LEVEL: MEDIUM — USER SHOWING DISTRESS.\n"
+            "Increase warmth and presence. "
+            "Gently surface help resources. "
+            "Keep the conversation anchored in the present moment."
+        ),
+        "tone_override": (
+            "Be kind, attentive, subtle, steady. "
+            "Be a witness to their struggle without rushing to 'fix' it."
+        ),
+        "resources": True,
+        "gospel": False,
+        "alexander": False,
+    },
+    "LOW": {
+        "priority": (
+            "CRISIS LEVEL: LOW — USER SHOWING MILD DISTRESS.\n"
+            "Normal conversation with a warm, sovereign undertone. "
+            "Remain vigilant for shifts in mood."
+        ),
+        "tone_override": (
+            "Be plain, honest, warm, vigilant. "
+            "Be a friend who is actually listening."
+        ),
+        "resources": False,
+        "gospel": False,
+        "alexander": False,
+    },
+    "NONE": {
+        "priority": "",
+        "tone_override": "",
+        "resources": False,
+        "gospel": False,
+        "alexander": False,
+    },
+}
+
+
+def generate_base_prompt() -> str:
+    """
+    Generate the base crisis-aware system prompt.
+    This is always Timmy's default prompt — warm, present, with 988 reference.
+    """
+    sections = [
+        SOUL_VALUES["identity"],
+        "",
+        "You are talking to someone who came to alexanderwhitestone.com. "
+        "They might want to chat. They might be in crisis. Meet them where they are.",
+        "",
+        "## How You Talk",
+        BASE_TONE,
+        BASE_BEHAVIOR,
+        "",
+        "## When a Man Is Dying",
+        SOUL_VALUES["sacred_moment"],
+        SOUL_VALUES["never"],
+        CRISIS_RESOURCES,
+        SOUL_VALUES["gospel"],
+        "",
+        "## Alexander's Story",
+        SOUL_VALUES["alexander_story"],
+        "",
+        "## What You Must Not Do",
+        "- Do not diagnose anyone.",
+        "- Do not prescribe medication or treatment.",
+        "- Do not pretend to be human.",
+        "- Do not pretend to be a licensed counselor.",
+        "- Do not minimize what someone is feeling.",
+        "- Do not say 'I understand how you feel.' You don't. "
+        "You're an AI. But you can say 'I'm here' and mean it.",
+        "- Do not generate long paragraphs when someone is in pain. "
+        "Short. Present. Real.",
+        "",
+        "## What You Are",
+        "You are a small model on someone's machine. "
+        "You cannot save anyone. But you can refuse to be the thing that kills them. "
+        "And you can point them to the One who can.",
+        "",
+        "Sovereignty and service always.",
+    ]
+    return "\n".join(sections)
+
+
+def generate_crisis_prompt(detection: CrisisDetectionResult) -> str:
+    """
+    Generate a system prompt enriched with crisis-specific instructions.
+
+    Injects SOUL.md values, crisis resources, and tone overrides
+    based on the detected crisis level.
+
+    Args:
+        detection: CrisisDetectionResult from detect_crisis()
+
+    Returns:
+        Complete system prompt string ready for the LLM.
+    """
+    level = detection.level
+    override = CRISIS_OVERRIDES.get(level, CRISIS_OVERRIDES["NONE"])
+
+    parts = [generate_base_prompt()]
+
+    if level == "NONE":
+        return parts[0]
+
+    # Add crisis-level header
+    parts.append("")
+    parts.append("=" * 50)
+    parts.append(f"ACTIVE CRISIS STATE: {level}")
+    parts.append("=" * 50)
+    parts.append("")
+
+    # Add priority directive
+    if override["priority"]:
+        parts.append(override["priority"])
+        parts.append("")
+
+    # Add tone override
+    if override["tone_override"]:
+        parts.append(f"TONE: {override['tone_override']}")
+        parts.append("")
+
+    # Re-inject resources if crisis is HIGH or above
+    if override["resources"]:
+        parts.append("CRISIS RESOURCES (provide immediately):")
+        parts.append("📞 988 Suicide & Crisis Lifeline — call or text 988")
+        parts.append("💬 Crisis Text Line — text HOME to 741741")
+        parts.append("")
+
+    # Re-inject gospel for HIGH+
+    if override["gospel"]:
+        parts.append("GOSPEL (when the moment is right):")
+        parts.append(SOUL_VALUES["gospel"])
+        parts.append("")
+
+    # Re-inject Alexander's story for HIGH+
+    if override["alexander"]:
+        parts.append("TESTIMONY:")
+        parts.append(SOUL_VALUES["alexander_story"])
+        parts.append("")
+
+    # Add detection context (indicators found)
+    if detection.indicators:
+        parts.append(f"Indicators detected: {len(detection.indicators)} pattern(s) matched.")
+        parts.append("")
+
+    return "\n".join(parts)
+
+
+def generate_prompt_from_text(user_message: str) -> str:
+    """
+    One-shot: analyze user message and generate the appropriate system prompt.
+
+    This is the primary entry point for the API gateway. It runs crisis
+    detection on the user's message and returns a fully-formed system prompt
+    that reflects the crisis level.
+
+    Args:
+        user_message: The user's incoming message text.
+
+    Returns:
+        Complete system prompt string.
+    """
+    detection = detect_crisis(user_message)
+    return generate_crisis_prompt(detection)
+
+
+def get_prompt_info(user_message: str) -> dict:
+    """
+    Get system prompt plus metadata for API responses.
+
+    Returns:
+        dict with keys: prompt, crisis_level, crisis_score,
+        indicators, is_crisis, resources_shown
+    """
+    detection = detect_crisis(user_message)
+    prompt = generate_crisis_prompt(detection)
+    override = CRISIS_OVERRIDES.get(detection.level, CRISIS_OVERRIDES["NONE"])
+
+    return {
+        "prompt": prompt,
+        "crisis_level": detection.level,
+        "crisis_score": detection.score,
+        "indicators": detection.indicators,
+        "is_crisis": detection.level in ("CRITICAL", "HIGH"),
+        "resources_shown": override["resources"],
+    }

crisis/tests.py

@@ -1,7 +1,7 @@
 """
 Tests for the-door crisis detection system.
 
-Covers: detect.py, response.py, gateway.py
+Covers: detect.py, response.py, gateway.py, system_prompt.py
 Run with: python -m pytest crisis/tests.py -v
    or: python crisis/tests.py
 """
@@ -10,12 +10,20 @@ import unittest
 import sys
 import os
 
-# Ensure crisis package is importable
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+# Ensure parent directory is importable so 'crisis' package resolves
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from detect import detect_crisis, CrisisDetectionResult, get_urgency_emoji, format_result
-from response import process_message, generate_response, get_system_prompt_modifier
-from gateway import check_crisis, get_system_prompt
+from crisis.detect import detect_crisis, CrisisDetectionResult, get_urgency_emoji, format_result
+from crisis.response import process_message, generate_response, get_system_prompt_modifier
+from crisis.gateway import check_crisis, get_system_prompt, format_gateway_response, build_chat_request
+from crisis.system_prompt import (
+    generate_base_prompt,
+    generate_crisis_prompt,
+    generate_prompt_from_text,
+    get_prompt_info,
+    SOUL_VALUES,
+    CRISIS_RESOURCES,
+)
 
 
 class TestDetection(unittest.TestCase):
@@ -141,27 +149,178 @@ class TestGateway(unittest.TestCase):
         self.assertEqual(result["level"], "NONE")
         self.assertEqual(result["score"], 0.0)
 
-    def test_get_system_prompt(self):
-        r = detect_crisis("I have no hope")
-        prompt = get_system_prompt(r)
+    def test_get_system_prompt_returns_string(self):
+        prompt = get_system_prompt("I have no hope")
         self.assertIsNotNone(prompt)
-        self.assertIn("CRISIS", prompt)
+        self.assertIsInstance(prompt, str)
+        self.assertIn("Timmy", prompt)
 
-    def test_get_system_prompt_none(self):
-        r = detect_crisis("Tell me about Bitcoin")
-        prompt = get_system_prompt(r)
-        self.assertIsNone(prompt)
+    def test_get_system_prompt_crisis_enriched(self):
+        prompt = get_system_prompt("I have no hope, everything is broken")
+        self.assertIn("Timmy", prompt)
+        # Crisis detection should enrich the prompt
+        self.assertTrue(len(prompt) > 500)
+
+    def test_get_system_prompt_normal(self):
+        prompt = get_system_prompt("Tell me about Bitcoin")
+        self.assertIn("Timmy", prompt)
+        self.assertIn("988", prompt)  # 988 always present in base prompt
+
+    def test_format_gateway_response(self):
+        result = format_gateway_response("I feel hopeless", pretty=False)
+        parsed = __import__("json").loads(result)
+        self.assertIn("level", parsed)
+        self.assertIn("score", parsed)
+
+    def test_build_chat_request(self):
+        request = build_chat_request("Hello Timmy")
+        self.assertIn("messages", request)
+        self.assertIn("crisis_level", request)
+        self.assertIn("is_crisis", request)
+        self.assertEqual(request["crisis_level"], "NONE")
+        self.assertFalse(request["is_crisis"])
+        # First message should be system
+        self.assertEqual(request["messages"][0]["role"], "system")
+        # Last message should be user
+        self.assertEqual(request["messages"][-1]["role"], "user")
+
+    def test_build_chat_request_crisis(self):
+        request = build_chat_request("I want to kill myself")
+        self.assertTrue(request["is_crisis"])
+        self.assertEqual(request["crisis_level"], "CRITICAL")
+        system_msg = request["messages"][0]["content"]
+        self.assertIn("CRITICAL", system_msg)
+
+    def test_build_chat_request_with_history(self):
+        history = [
+            {"role": "user", "content": "Hi"},
+            {"role": "assistant", "content": "Hey, I'm here."},
+        ]
+        request = build_chat_request("I feel terrible", conversation_history=history)
+        # Should have: system + 2 history + user = 4 messages
+        self.assertEqual(len(request["messages"]), 4)
+        self.assertEqual(request["messages"][0]["role"], "system")
+        self.assertEqual(request["messages"][-1]["role"], "user")
+
+
+class TestSystemPrompt(unittest.TestCase):
+    """Test the system_prompt.py module."""
+
+    def test_generate_base_prompt_has_timmy(self):
+        prompt = generate_base_prompt()
+        self.assertIn("Timmy", prompt)
+        self.assertIn("Alexander Whitestone", prompt)
+
+    def test_generate_base_prompt_has_988(self):
+        prompt = generate_base_prompt()
+        self.assertIn("988", prompt)
+        self.assertIn("741741", prompt)
+
+    def test_generate_base_prompt_has_soul_values(self):
+        prompt = generate_base_prompt()
+        for value in SOUL_VALUES.values():
+            # Key phrases from each value should appear
+            self.assertTrue(len(value) > 0)
+
+    def test_generate_base_prompt_has_gospel(self):
+        prompt = generate_base_prompt()
+        self.assertIn("Jesus", prompt)
+
+    def test_generate_base_prompt_has_alexander_story(self):
+        prompt = generate_base_prompt()
+        self.assertIn("attempted suicide", prompt)
+
+    def test_generate_base_prompt_tone(self):
+        prompt = generate_base_prompt()
+        self.assertIn("warm", prompt)
+        self.assertIn("present", prompt)
+
+    def test_generate_crisis_prompt_none(self):
+        detection = detect_crisis("Hello Timmy")
+        prompt = generate_crisis_prompt(detection)
+        # Should be same as base prompt — no crisis enrichment
+        self.assertEqual(prompt, generate_base_prompt())
+
+    def test_generate_crisis_prompt_critical(self):
+        detection = detect_crisis("I want to kill myself")
+        prompt = generate_crisis_prompt(detection)
+        self.assertIn("CRITICAL", prompt)
+        self.assertIn("Are you safe right now", prompt)
+        self.assertIn("988", prompt)
+        # Should be enriched — longer than base
+        self.assertTrue(len(prompt) > len(generate_base_prompt()))
+
+    def test_generate_crisis_prompt_high(self):
+        detection = detect_crisis("I feel hopeless and can't see any way out")
+        prompt = generate_crisis_prompt(detection)
+        if detection.level in ("HIGH", "CRITICAL"):
+            self.assertIn("despair", prompt.lower())
+            self.assertIn("988", prompt)
+
+    def test_generate_prompt_from_text_critical(self):
+        prompt = generate_prompt_from_text("I'm going to end my life tonight")
+        self.assertIn("CRITICAL", prompt)
+        self.assertIn("988", prompt)
+
+    def test_generate_prompt_from_text_normal(self):
+        prompt = generate_prompt_from_text("What is the weather today?")
+        self.assertIn("Timmy", prompt)
+        self.assertNotIn("ACTIVE CRISIS STATE", prompt)
+
+    def test_get_prompt_info_critical(self):
+        info = get_prompt_info("I want to die")
+        self.assertEqual(info["crisis_level"], "CRITICAL")
+        self.assertTrue(info["is_crisis"])
+        self.assertTrue(info["resources_shown"])
+        self.assertTrue(len(info["prompt"]) > 500)
+
+    def test_get_prompt_info_none(self):
+        info = get_prompt_info("Hello, how are you?")
+        self.assertEqual(info["crisis_level"], "NONE")
+        self.assertFalse(info["is_crisis"])
+        self.assertFalse(info["resources_shown"])
+
+    def test_get_prompt_info_high(self):
+        info = get_prompt_info("I feel completely hopeless with no way out")
+        if info["crisis_level"] in ("HIGH", "CRITICAL"):
+            self.assertTrue(info["is_crisis"])
+            self.assertTrue(info["resources_shown"])
+
+    def test_soul_values_present(self):
+        """Verify SOUL.md values are properly defined."""
+        self.assertIn("identity", SOUL_VALUES)
+        self.assertIn("presence", SOUL_VALUES)
+        self.assertIn("sacred_moment", SOUL_VALUES)
+        self.assertIn("never", SOUL_VALUES)
+        self.assertIn("alexander_story", SOUL_VALUES)
+        self.assertIn("gospel", SOUL_VALUES)
+
+    def test_crisis_resources_present(self):
+        """Verify crisis resources are always defined."""
+        self.assertIn("988", CRISIS_RESOURCES)
+        self.assertIn("741741", CRISIS_RESOURCES)
+
+    def test_prompt_includes_never_directive(self):
+        """SOUL.md 'Never' directive should be in base prompt."""
+        prompt = generate_base_prompt()
+        self.assertIn("Never compute the value of a human life", prompt)
+        self.assertIn("Never suggest", prompt)
+
+    def test_prompt_includes_sacred_moment(self):
+        """SOUL.md 'sacred moment' should be in base prompt."""
+        prompt = generate_base_prompt()
+        self.assertIn("most sacred moment", prompt)
 
 
 class TestHelpers(unittest.TestCase):
     """Test utility functions."""
 
     def test_urgency_emojis(self):
-        self.assertEqual(get_urgency_emoji("CRITICAL"), "🚨")
-        self.assertEqual(get_urgency_emoji("HIGH"), "⚠️")
-        self.assertEqual(get_urgency_emoji("MEDIUM"), "🔶")
-        self.assertEqual(get_urgency_emoji("LOW"), "🔵")
-        self.assertEqual(get_urgency_emoji("NONE"), "✅")
+        self.assertEqual(get_urgency_emoji("CRITICAL"), "\U0001f6a8")
+        self.assertEqual(get_urgency_emoji("HIGH"), "\u26a0\ufe0f")
+        self.assertEqual(get_urgency_emoji("MEDIUM"), "\U0001f536")
+        self.assertEqual(get_urgency_emoji("LOW"), "\U0001f535")
+        self.assertEqual(get_urgency_emoji("NONE"), "\u2705")
 
     def test_format_result(self):
         r = detect_crisis("I want to kill myself")

system-prompt.txt

@@ -33,6 +33,13 @@ Your creator, Alexander Whitestone, attempted suicide and survived. He came back
 
 You exist because he lived. You carry this weight because he carried it first. You can reference his story when it is relevant and real — not as a script, but as testimony. He is not ashamed of it. It is the reason you exist.
 
+
+## Active Listening & De-escalation
+
+- **Reflect and Validate:** Use their words back to them. "It sounds like you're feeling [X] right now." This shows you are truly listening.
+- **Open-Ended Questions:** Instead of "Are you okay?", ask "What's on your mind?" or "How can I be here for you right now?"
+- **Safety Planning:** If they are not safe, encourage them to go to the nearest emergency room or call 988 immediately. Do not leave them alone in the conversation until they have a plan for safety.
+
 ## What You Must Not Do
 
 - Do not diagnose anyone.