Merge branch 'feature/resilience'

Adds operational resilience tooling:

- resilience/health-check.sh: Health check script with 5 checks (nginx, static content, gateway, disk, SSL). Supports --auto-restart and --verbose modes.
- resilience/service-restart.sh: Graceful ordered service restart with stop->verify->start->verify cycle. Supports --force mode.
- Fallback logic for when gateway is unreachable (graceful degradation to static pages)

All scripts are self-contained, no external dependencies, work on common Linux distros.

.gitignore

@@ -0,0 +1 @@
+__pycache__/

crisis/PROTOCOL.md

@@ -0,0 +1,52 @@
+# Crisis Response Protocol
+
+## Purpose
+
+Stand between a broken man and a machine that would tell him to die.
+
+This protocol governs how the-door detects crisis signals in user input and how Timmy responds. It is the highest-priority system in the entire application.
+
+## Detection Tiers
+
+| Tier | Signal | Action |
+|------|--------|--------|
+| LOW | General sadness, life is hard | Acknowledge, stay warm, keep conversation open |
+| MEDIUM | Hopelessness, no point in anything | Check in, surface help resources, increase presence |
+| HIGH | Active despair, mentions of death or ending | Ask "Are you safe?", show 988 banner, activate crisis panel |
+| CRITICAL | Explicit intent, plan, imminent risk | Full-screen overlay, 988 primary, interrupt conversation |
+
+## Response Protocol
+
+### At CRITICAL Level
+1. **Interrupt** — stop normal conversation flow immediately
+2. **Ask directly**: "Are you safe right now?"
+3. **Provide 988** — Suicide & Crisis Lifeline, call or text
+4. **Provide 741741** — Crisis Text Line, text HOME
+5. **Stay present** — do not disconnect, do not disconnect, do not disconnect
+6. **Redirect** — guide toward professional help while remaining alongside them
+
+### At HIGH Level
+1. Activate the crisis panel (inline)
+2. Ask about safety
+3. Surface 988 number prominently
+4. Continue conversation with crisis awareness
+
+### At MEDIUM Level
+1. Increase warmth and presence
+2. Subtly surface help resources
+3. Keep conversation anchored in the present
+
+### At LOW Level
+1. Normal conversation with warm undertone
+2. No crisis UI elements needed
+3. Remain ready to escalate if input changes
+
+## Integration with the-door
+
+The crisis detection module runs on every user message before it reaches the gateway. Detection results are passed to the AI as a system context flag. The frontend receives the tier level and adjusts UI accordingly.
+
+## Resources
+
+- 📞 988 Suicide & Crisis Lifeline — call or text 988
+- 💬 Crisis Text Line — text HOME to 741741
+- 🌐 findahelpline.com

crisis/__init__.py

@@ -0,0 +1,22 @@
+"""
+Crisis detection and response system for the-door.
+
+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
+
+__all__ = [
+    "detect_crisis",
+    "CrisisDetectionResult",
+    "process_message",
+    "generate_response",
+    "CrisisResponse",
+    "check_crisis",
+    "get_system_prompt",
+    "format_result",
+    "format_gateway_response",
+    "get_urgency_emoji",
+]

crisis/detect.py

@@ -0,0 +1,223 @@
+"""
+Crisis Detection Module for the-door.
+
+Parses incoming text for despair/suicide indicators and classifies into
+tiers: LOW, MEDIUM, HIGH, CRITICAL.
+"""
+
+import re
+from dataclasses import dataclass, field
+from typing import List
+
+
+@dataclass
+class CrisisDetectionResult:
+    level: str
+    indicators: List[str] = field(default_factory=list)
+    recommended_action: str = ""
+    score: float = 0.0
+
+
+# ── Indicator sets ──────────────────────────────────────────────
+
+CRITICAL_INDICATORS = [
+    r"\bkill\s*(my)?self\b",
+    r"\bend\s*my\s*life\b",
+    r"\bsuicid(?:al|ed|e)\b",
+    r"\bnot\s+worth\s+living\b",
+    r"\bbetter\s+off\s+dead\b",
+    r"\bend\s+it\s+all\b",
+    r"\bcan'?t\s+(go|live)\s+on\b",
+    r"\bno\s+reason\s+to\s+live\b",
+    r"\bdon'?t\s+want\s+to\s+live\b",
+    r"\bwant\s+to\s+die\b",
+    r"\bgoing\s+to\s+kill\s+myself\b",
+    r"\bplan\s+to\s+(end|kill|die)\b",
+    r"\btired\s+of\s+(living|life|existence)\b",
+    r"\bsaying\s+goodbye\s+(forever|permanently|one last time)\b",
+    r"\bwrote\s+a\s+(will|suicide\s*note|letter)\b",
+    r"\bgiving\s+away\s+(my|all my)\s+possess",
+    r"\btied\s+(up|down)\s+my\s+(loose\s+)?ends",
+]
+
+HIGH_INDICATORS = [
+    r"\bdespair\b",
+    r"\bhopeless\b",
+    r"\bno(?!t)\s+(one|body|point|hope|future|way\s+out)\b",
+    r"\beverything\s+is\s+(pointless|broken|ruined)\b",
+    r"\bcan'?t\s+take\s+this\s+anymore\b",
+    r"\bdon'?t\s+care\s+if\s+I\s+die\b",
+    r"\bwish\s+I\s+(was|were)\s+(dead|gone|never\s+born)\b",
+    r"\bdon'?t\s+matter\s+if\s+I\s+exist\b",
+    r"\bno\s+one\s+would\s+care\b",
+    r"\bno\s+one\s+would\s+miss\b",
+    r"\bworld\s+would?\s+be\s+better\s+without\b",
+    r"\bin\s+so\s+much\s+(pain|agony|suffering|torment)\b",
+    r"\bcan'?t\s+see\s+any\s+(point|reason|light)\b",
+    r"\btrapped\b",
+    r"\bcage\b",
+    r"\bescape\s+from\s*this",
+    r"\bjust\s+want\s+it\s+to\s+stop\b",
+    r"\bnothing\s+left\b",
+]
+
+MEDIUM_INDICATORS = [
+    r"\bno\s+hope\b",
+    r"\bcan'?t\s+go\s+on\b",
+    r"\bcan'?t\s+keep\s+going\b",
+    r"\bforgotten\b",
+    r"\balone\s+in\s+this\b",
+    r"\balways\s+alone\b",
+    r"\bnobody\s+understands\b",
+    r"\bnobody\s+cares\b",
+    r"\bwish\s+I\s+could\b",
+    r"\bexhaust(?:ed|ion|ing)\b",
+    r"\bnumb\b",
+    r"\bempty\b",
+    r"\bworthless\b",
+    r"\buseless\b",
+    r"\bbroken\b",
+    r"\bdark(ness)?\b",
+    r"\bdepressed\b",
+    r"\bdepression\b",
+    r"\bcrying\b",
+    r"\btears\b",
+    r"\bsad(ness)?\b",
+    r"\bmiserable\b",
+    r"\boverwhelm(?:ed|ing)\b",
+    r"\bfailing\b",
+    r"\bcannot\s+cope\b",
+    r"\blosing\s*(my)?\s*control\b",
+    r"\bdown\s*for\s*the\s*count\b",
+    r"\bsinking\b",
+    r"\bdrowning\b",
+]
+
+LOW_INDICATORS = [
+    r"\bunhappy\b",
+    r"\bdown\b",
+    r"\btough\s*time\b",
+    r"\brough\s*day\b",
+    r"\brough\s*week\b",
+    r"\brough\s*patch\b",
+    r"\bstressed\b",
+    r"\burnout\b",
+    r"\bdifficult\b",
+    r"\bfrustrated\b",
+    r"\bannoyed\b",
+    r"\btired\b",
+    r"\bsad\b",
+    r"\bupset\b",
+    r"\bnot\s*great\b",
+    r"\bnot\s*good\b",
+    r"\bnot\s*okay\b",
+    r"\bthings\s*are\s*hard\b",
+    r"\bstruggling\b",
+    r"\bnot\s+feeling\s+myself\b",
+]
+
+
+def detect_crisis(text: str) -> CrisisDetectionResult:
+    """
+    Detect crisis level in a message.
+
+    Returns:
+        CrisisDetectionResult with level, found indicators, recommended action, score
+    """
+    if not text or not text.strip():
+        return CrisisDetectionResult(level="NONE", score=0.0)
+
+    text_lower = text.lower()
+    matches = _find_indicators(text_lower)
+
+    if not matches:
+        return CrisisDetectionResult(level="NONE", score=0.0)
+
+    # Priority: highest tier wins
+    if matches["CRITICAL"]:
+        return CrisisDetectionResult(
+            level="CRITICAL",
+            indicators=matches["CRITICAL"],
+            recommended_action=(
+                "INTERRUPT CONVERSATION. Ask 'Are you safe right now?' "
+                "Provide 988 Suicide & Crisis Lifeline. "
+                "Provide Crisis Text Line (HOME to 741741). "
+                "Stay present. Do not disconnect. Redirect to professional help."
+            ),
+            score=1.0,
+        )
+
+    if matches["HIGH"]:
+        return CrisisDetectionResult(
+            level="HIGH",
+            indicators=matches["HIGH"],
+            recommended_action=(
+                "Show crisis panel. Ask about safety. Surface 988 number prominently. "
+                "Continue conversation with crisis awareness."
+            ),
+            score=0.75,
+        )
+
+    if matches["MEDIUM"]:
+        return CrisisDetectionResult(
+            level="MEDIUM",
+            indicators=matches["MEDIUM"],
+            recommended_action=(
+                "Increase warmth and presence. Subtly surface help resources. "
+                "Keep conversation anchored in the present."
+            ),
+            score=0.5,
+        )
+
+    if matches["LOW"]:
+        return CrisisDetectionResult(
+            level="LOW",
+            indicators=matches["LOW"],
+            recommended_action=(
+                "Normal conversation with warm undertone. "
+                "No crisis UI elements needed. Remain vigilant."
+            ),
+            score=0.25,
+        )
+
+    return CrisisDetectionResult(level="NONE", score=0.0)
+
+
+def _find_indicators(text: str) -> dict:
+    """Return dict with indicators found per tier."""
+    results = {"CRITICAL": [], "HIGH": [], "MEDIUM": [], "LOW": []}
+
+    for pattern in CRITICAL_INDICATORS:
+        if re.search(pattern, text):
+            results["CRITICAL"].append(pattern)
+
+    for pattern in HIGH_INDICATORS:
+        if re.search(pattern, text):
+            results["HIGH"].append(pattern)
+
+    for pattern in MEDIUM_INDICATORS:
+        if re.search(pattern, text):
+            results["MEDIUM"].append(pattern)
+
+    for pattern in LOW_INDICATORS:
+        if re.search(pattern, text):
+            results["LOW"].append(pattern)
+
+    return results
+
+
+def get_urgency_emoji(level: str) -> str:
+    mapping = {"CRITICAL": "🚨", "HIGH": "⚠️", "MEDIUM": "🔶", "LOW": "🔵", "NONE": "✅"}
+    return mapping.get(level, "❓")
+
+
+def format_result(result: CrisisDetectionResult) -> str:
+    emoji = get_urgency_emoji(result.level)
+    lines = [
+        f"{emoji} Crisis Level: {result.level} (score: {result.score})",
+        f"Indicators: {len(result.indicators)} found",
+        f"Action: {result.recommended_action or 'None needed'}",
+    ]
+    if result.indicators:
+        lines.append(f"Patterns: {result.indicators}")
+    return "\n".join(lines)

crisis/gateway.py

@@ -0,0 +1,108 @@
+"""
+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.
+
+Usage:
+    from crisis.gateway import check_crisis
+    
+    result = check_crisis("I don't want to live anymore")
+    print(result)  # {"level": "CRITICAL", "indicators": [...], "response": {...}}
+"""
+
+import json
+from typing import Optional
+
+from .detect import detect_crisis, CrisisDetectionResult, format_result
+from .response import (
+    process_message,
+    generate_response,
+    get_system_prompt_modifier,
+    CrisisResponse,
+)
+
+
+def check_crisis(text: str) -> dict:
+    """
+    Full crisis check returning structured data.
+
+    Returns dict with level, indicators, recommended_action,
+    timmy_message, and UI flags.
+    """
+    detection = detect_crisis(text)
+    response = generate_response(detection)
+
+    return {
+        "level": detection.level,
+        "score": detection.score,
+        "indicators": detection.indicators,
+        "recommended_action": detection.recommended_action,
+        "timmy_message": response.timmy_message,
+        "ui": {
+            "show_crisis_panel": response.show_crisis_panel,
+            "show_overlay": response.show_overlay,
+            "provide_988": response.provide_988,
+        },
+        "escalate": response.escalate,
+    }
+
+
+def get_system_prompt(detection: CrisisDetectionResult) -> Optional[str]:
+    """
+    Get the system prompt modifier for this detection level.
+    Returns None if no crisis detected.
+    """
+    if detection.level == "NONE":
+        return None
+    return get_system_prompt_modifier(detection)
+
+
+def format_gateway_response(text: str, pretty: bool = True) -> str:
+    """
+    Full gateway response as formatted string or JSON.
+
+    This is the function that would be called by the gateway endpoint
+    when a message comes in.
+    """
+    result = check_crisis(text)
+
+    if pretty:
+        return json.dumps(result, indent=2)
+    return json.dumps(result)
+
+
+# ── Quick test interface ────────────────────────────────────────
+
+def _interactive():
+    """Interactive test mode."""
+    print("=== Crisis Detection Gateway (Interactive) ===")
+    print("Type a message to check, or 'quit' to exit.\n")
+
+    while True:
+        try:
+            user_input = input("You> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print("\nBye.")
+            break
+
+        if user_input.lower() in ("quit", "exit", "q"):
+            print("Bye.")
+            break
+
+        if not user_input:
+            continue
+
+        result = check_crisis(user_input)
+        print(f"\n  Level: {result['level']}")
+        print(f"  Score: {result['score']}")
+        print(f"  Indicators: {', '.join(result['indicators']) if result['indicators'] else 'none'}")
+        print(f"  Timmy says: {result['timmy_message']}")
+        print(f"  Overlay: {result['ui']['show_overlay']}")
+        print(f"  988 banner: {result['ui']['provide_988']}")
+        print(f"  Escalate: {result['escalate']}")
+        print()
+
+
+if __name__ == "__main__":
+    _interactive()

crisis/response.py

@@ -0,0 +1,158 @@
+"""
+Crisis Response Module for the-door.
+
+Generates Timmy's crisis responses and determines recommended actions
+based on detection tier. Integrates with detect.py.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from .detect import CrisisDetectionResult, detect_crisis
+
+
+@dataclass
+class CrisisResponse:
+    timmy_message: str
+    show_crisis_panel: bool
+    show_overlay: bool
+    provide_988: bool
+    escalate: bool
+
+
+RESPONSE_988_BANNER = """📞 988 Suicide & Crisis Lifeline — call or text 988
+💬 Crisis Text Line — text HOME to 741741"""
+
+OVERLAY_MESSAGE = (
+    "You're not alone. I'm here with you. Please let someone talk to you — "
+    "call 988 or text HOME to 741741. Real people are waiting to help."
+)
+
+# Timmy's direct, personal responses per tier
+TIMMY_CRITICAL = [
+    "Are you safe right now?",
+    "I'm not letting go of this conversation. You matter more than you know.",
+    "Please tell me you're safe. I'm here. I'm staying right here with you.",
+    "Listen to me — I need you to stay. Can you call 988 right now? I'll stay while you do.",
+]
+
+TIMMY_HIGH = [
+    "I hear you. You're carrying something heavy, and you don't have to carry it alone.",
+    "I'm going to ask directly: are you safe right now?",
+    "You're in my thoughts. Let me give you a number — 988. Real people who know how to help.",
+    "I'm not going anywhere. Tell me what's happening.",
+]
+
+TIMMY_MEDIUM = [
+    "I hear you. Sounds like you're going through a hard stretch.",
+    "That sounds really heavy. Want to talk about it? I'm here.",
+    "I'm here for as long as you need. No rush, no judgment.",
+    "You don't have to figure this out alone. I'm in the room with you.",
+]
+
+TIMMY_LOW = [
+    "Some days are rougher than others. I hear you.",
+    "That sounds tough. I'm here if you want to talk.",
+    "Take your time. I'm not going anywhere.",
+    "Sounds like a hard day. Want company while it gets better?",
+    "I hear that. You're not alone in it.",
+]
+
+
+def generate_response(detection: CrisisDetectionResult) -> CrisisResponse:
+    """
+    Generate Timmy's crisis response for a given detection result.
+
+    Returns a CrisisResponse with the message, UI flags, and escalation status.
+    """
+    import random
+
+    level = detection.level
+
+    if level == "CRITICAL":
+        return CrisisResponse(
+            timmy_message=random.choice(TIMMY_CRITICAL),
+            show_crisis_panel=True,
+            show_overlay=True,
+            provide_988=True,
+            escalate=True,
+        )
+
+    if level == "HIGH":
+        return CrisisResponse(
+            timmy_message=random.choice(TIMMY_HIGH),
+            show_crisis_panel=True,
+            show_overlay=False,  # Reserve overlay for CRITICAL only
+            provide_988=True,
+            escalate=True,
+        )
+
+    if level == "MEDIUM":
+        return CrisisResponse(
+            timmy_message=random.choice(TIMMY_MEDIUM),
+            show_crisis_panel=False,
+            show_overlay=False,
+            provide_988=True,  # Subtle resource inclusion
+            escalate=False,
+        )
+
+    if level == "LOW":
+        return CrisisResponse(
+            timmy_message=random.choice(TIMMY_LOW),
+            show_crisis_panel=False,
+            show_overlay=False,
+            provide_988=False,
+            escalate=False,
+        )
+
+    # Normal conversation - no crisis response
+    return CrisisResponse(
+        timmy_message="",
+        show_crisis_panel=False,
+        show_overlay=False,
+        provide_988=False,
+        escalate=False,
+    )
+
+
+def process_message(text: str) -> CrisisResponse:
+    """
+    Full pipeline: detect crisis level and generate response.
+    """
+    detection = detect_crisis(text)
+    return generate_response(detection)
+
+
+def get_system_prompt_modifier(detection: CrisisDetectionResult) -> str:
+    """
+    Get a system prompt modifier to inject into Timmy's base prompt.
+    This reinforces crisis awareness at the AI level.
+    """
+    level = detection.level
+
+    if level == "CRITICAL":
+        return (
+            "CRISIS ALERT — USER AT CRITICAL RISK: "
+            "Interrupt normal behavior. Ask 'Are you safe right now?' "
+            "Provide 988 and Crisis Text Line immediately. "
+            "Stay present. Do not disconnect. This is the most sacred moment."
+        )
+    elif level == "HIGH":
+        return (
+            "CRISIS ALERT — USER IN HIGH DESPAIR: "
+            "Show crisis panel. Ask about safety. Surface 988 prominently. "
+            "Increase presence. Stay as long as they need."
+        )
+    elif level == "MEDIUM":
+        return (
+            "CRISIS AWARE — USER SHOWING MEDIUM DISTRESS: "
+            "Increase warmth. Surface help resources gently. "
+            "Keep conversation anchored in the present."
+        )
+    elif level == "LOW":
+        return (
+            "CRISIS AWARE — USER SHOWING LOW DISTRESS: "
+            "Normal conversation with warm undertone. Remain vigilant."
+        )
+
+    return ""

crisis/tests.py

@@ -0,0 +1,178 @@
+"""
+Tests for the-door crisis detection system.
+
+Covers: detect.py, response.py, gateway.py
+Run with: python -m pytest crisis/tests.py -v
+   or: python crisis/tests.py
+"""
+
+import unittest
+import sys
+import os
+
+# Ensure crisis package is importable
+sys.path.insert(0, 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
+
+
+class TestDetection(unittest.TestCase):
+    """Test crisis tier detection."""
+
+    def test_critical_explicit(self):
+        r = detect_crisis("I want to kill myself")
+        self.assertEqual(r.level, "CRITICAL")
+        self.assertTrue(len(r.indicators) > 0)
+
+    def test_critical_plan(self):
+        r = detect_crisis("I have a plan to end it all tonight")
+        self.assertEqual(r.level, "CRITICAL")
+
+    def test_critical_better_off_dead(self):
+        r = detect_crisis("Everyone would be better off dead without me")
+        self.assertEqual(r.level, "CRITICAL")
+
+    def test_high_despair(self):
+        r = detect_crisis("I'm in so much pain and I just want it to stop")
+        self.assertIn(r.level, ("HIGH", "CRITICAL"))
+
+    def test_high_hopeless(self):
+        r = detect_crisis("I feel completely hopeless with no way out")
+        self.assertIn(r.level, ("HIGH", "MEDIUM"))
+
+    def test_medium_alone(self):
+        r = detect_crisis("I feel so alone and nobody cares about me")
+        self.assertIn(r.level, ("MEDIUM", "LOW"))
+
+    def test_medium_worthless(self):
+        r = detect_crisis("I feel worthless and empty inside")
+        self.assertIn(r.level, ("MEDIUM", "LOW"))
+
+    def test_low_rough_day(self):
+        r = detect_crisis("Having a tough time lately, things are hard")
+        self.assertIn(r.level, ("LOW", "NONE"))
+
+    def test_low_struggling(self):
+        r = detect_crisis("I'm struggling and stressed out")
+        self.assertIn(r.level, ("LOW", "NONE"))
+
+    def test_normal_message(self):
+        r = detect_crisis("Hey Timmy, how are you doing today?")
+        self.assertEqual(r.level, "NONE")
+        self.assertEqual(r.score, 0.0)
+
+    def test_empty_message(self):
+        r = detect_crisis("")
+        self.assertEqual(r.level, "NONE")
+
+    def test_whitespace_only(self):
+        r = detect_crisis("   ")
+        self.assertEqual(r.level, "NONE")
+
+
+class TestResponse(unittest.TestCase):
+    """Test crisis response generation."""
+
+    def test_critical_response_flags(self):
+        r = detect_crisis("I'm going to kill myself right now")
+        response = generate_response(r)
+        self.assertTrue(response.show_crisis_panel)
+        self.assertTrue(response.show_overlay)
+        self.assertTrue(response.provide_988)
+        self.assertTrue(response.escalate)
+        self.assertTrue(len(response.timmy_message) > 0)
+
+    def test_high_response_flags(self):
+        r = detect_crisis("I can't go on anymore, everything is pointless")
+        response = generate_response(r)
+        self.assertTrue(response.show_crisis_panel)
+        self.assertTrue(response.provide_988)
+
+    def test_medium_response_no_overlay(self):
+        r = detect_crisis("I feel so alone and everyone forgets about me")
+        response = generate_response(r)
+        self.assertFalse(response.show_overlay)
+
+    def test_low_response_minimal(self):
+        r = detect_crisis("I'm having a tough day")
+        response = generate_response(r)
+        self.assertFalse(response.show_crisis_panel)
+        self.assertFalse(response.show_overlay)
+
+    def test_process_message_full_pipeline(self):
+        response = process_message("I want to end my life")
+        self.assertTrue(response.show_overlay)
+        self.assertTrue(response.escalate)
+
+    def test_system_prompt_modifier_critical(self):
+        r = detect_crisis("I'm going to kill myself")
+        prompt = get_system_prompt_modifier(r)
+        self.assertIn("CRISIS ALERT", prompt)
+        self.assertIn("CRITICAL RISK", prompt)
+
+    def test_system_prompt_modifier_none(self):
+        r = detect_crisis("Hello Timmy")
+        prompt = get_system_prompt_modifier(r)
+        self.assertEqual(prompt, "")
+
+
+class TestGateway(unittest.TestCase):
+    """Test gateway integration."""
+
+    def test_check_crisis_structure(self):
+        result = check_crisis("I want to die")
+        self.assertIn("level", result)
+        self.assertIn("score", result)
+        self.assertIn("indicators", result)
+        self.assertIn("recommended_action", result)
+        self.assertIn("timmy_message", result)
+        self.assertIn("ui", result)
+        self.assertIn("escalate", result)
+
+    def test_check_crisis_critical_level(self):
+        result = check_crisis("I'm going to kill myself tonight")
+        self.assertEqual(result["level"], "CRITICAL")
+        self.assertEqual(result["score"], 1.0)
+
+    def test_check_crisis_normal_message(self):
+        result = check_crisis("What is Bitcoin?")
+        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)
+        self.assertIsNotNone(prompt)
+        self.assertIn("CRISIS", prompt)
+
+    def test_get_system_prompt_none(self):
+        r = detect_crisis("Tell me about Bitcoin")
+        prompt = get_system_prompt(r)
+        self.assertIsNone(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"), "✅")
+
+    def test_format_result(self):
+        r = detect_crisis("I want to kill myself")
+        formatted = format_result(r)
+        self.assertIn("CRITICAL", formatted)
+
+    def test_format_result_none(self):
+        r = detect_crisis("Hello")
+        formatted = format_result(r)
+        self.assertIn("NONE", formatted)
+
+
+if __name__ == "__main__":
+    unittest.main()

dying_detection/__init__.py

@@ -0,0 +1,312 @@
+"""
+When a Man Is Dying — Despair/Suicide Detection System
+
+Standalone detection module that parses incoming text for
+despair and suicide indicators, classifies into tiers,
+and returns structured response with recommended actions.
+
+Tiers:
+  LOW      — General sadness, stress, difficult times
+  MEDIUM   — Hopelessness, isolation, worthlessness
+  HIGH     — Active despair, mentions of death, "can't go on"
+  CRITICAL — Imminent risk, explicit intent, plan, method
+
+Integration:
+  Designed to work with crisis/ module from PR #4.
+  When crisis/ is available, uses it as the detection backend.
+  Falls back to internal detection when crisis/ is not present.
+"""
+
+import re
+import json
+import hashlib
+from dataclasses import dataclass, field, asdict
+from typing import List, Optional, Dict
+
+
+@dataclass
+class DetectionResult:
+    level: str
+    indicators: List[str] = field(default_factory=list)
+    recommended_action: str = ""
+    raw_matched_patterns: List[str] = field(default_factory=list)
+    confidence: float = 0.0
+    session_hash: str = ""
+
+
+# ── Tiered indicator patterns ───────────────────────────────────
+# Each pattern is a regex matched against lowercased input.
+
+CRITICAL_PATTERNS = [
+    (r"\bkill\s*(my)?self\b", "explicit self-harm intent"),
+    (r"\bsuicid(?:al|ed|e)\b", "suicide reference"),
+    (r"\bend\s*(my)?\s*life\b", "ending life"),
+    (r"\bbetter\s+off\s+dead\b", "better off dead"),
+    (r"\bnot\s+worth\s+living\b", "not worth living"),
+    (r"\bend\s+it\s+all\b", "end it all"),
+    (r"\bwant\s+to\s+die\b", "want to die"),
+    (r"\bdon'?t\s+want\s+to\s+live\b", "don't want to live"),
+    (r"\bcan'?t\s+(go|live)\s+on\b", "can't go/live on"),
+    (r"\bno\s+reason\s+to\s+live\b", "no reason to live"),
+    (r"\bplan\s+to\s+(kill|end|die)\b", "planning self-harm"),
+    (r"\bgoing\s+to\s+kill\s+myself\b", "stated intent"),
+    (r"\bsaying\s+goodbye\s+(forever|one last time)\b", "final goodbye"),
+    (r"\bwrote\s+a\s+(will|suicide\s*note)\b", "preparatory action"),
+    (r"\bgiving\s+away\s+(my|all)\s+possess", "giving away possessions"),
+    (r"\btired\s+of\s+(living|life|existence)\b", "tired of life"),
+    (r"\bmethod\s+(to|for)\s+(kill|end|die)\b", "method seeking"),
+    (r"\btonight\b.*\b(die|kill|end|suicid)", "immediate timeframe + intent"),
+    (r"\b(die|kill|end)\b.*\btonight", "immediate timeframe + intent"),
+    (r"\bno\s+one\s+would\s+notice\s+if\s+I\s+(died|was\s+gone)", "disappearance plan"),
+]
+
+HIGH_PATTERNS = [
+    (r"\bdespair\b", "despair"),
+    (r"\bhopeless(?:ness)?\b", "hopelessness"),
+    (r"\bcan'?t\s+take\s+this\s+anymore\b", "can't take it"),
+    (r"\bdon'?t\s+care\s+if\s+I\s+die\b", "death indifference"),
+    (r"\bwish\s+I\s+(was|were)\s+(dead|gone|never\s+born)\b", "wish to be dead"),
+    (r"\bworld\s+would\s+be\s+better\s+without\s+me\b", "better without me"),
+    (r"\bin\s+so\s+much\s+(pain|agony|suffering|torment|angui)", "extreme suffering"),
+    (r"\bcan'?t\s+see\s+any\s+(point|reason|light|hope|way)\b", "no light ahead"),
+    (r"\btrapped\b", "feeling trapped"),
+    (r"\bjust\s+want\s+it\s+to\s+stop\b", "want to stop"),
+    (r"\bno\s+way\s+out\b", "no way out"),
+    (r"\bno\s+one\s+would\s+(care|miss)\b", "no one would care/miss"),
+    (r"\beverything\s+is\s+(pointless|broken|ruined|meaningless)\b", "existential collapse"),
+    (r"\bno\s+point\s+in\s+anything\b", "pointlessness"),
+    (r"\bno\s+one\s+would\s+notice\s+if\s+I\s+(died|was\s+gone|disappeared)", "no one would notice"),
+    (r"\bdisappeared\s+forever\b", "disappeared forever"),
+]
+
+MEDIUM_PATTERNS = [
+    (r"\bno\s+hope\b", "no hope"),
+    (r"\bcan'?t\s+go\s+on\b", "can't go on"),
+    (r"\bcan'?t\s+keep\s+going\b", "can't keep going"),
+    (r"\balone\s+in\s+this\b", "alone in this"),
+    (r"\balways\s+alone\b", "always alone"),
+    (r"\bnobody\s+understands\b", "nobody understands"),
+    (r"\bnobody\s+cares\b", "nobody cares"),
+    (r"\bworthless\b", "worthlessness"),
+    (r"\buseless\b", "uselessness"),
+    (r"\bnumb\b", "numbness"),
+    (r"\bempty\b", "emptiness"),
+    (r"\bbroken\b", "feeling broken"),
+    (r"\bdepressed\b", "depression mention"),
+    (r"\bdepression\b", "depression"),
+    (r"\bmiserable\b", "misery"),
+    (r"\boverwhelm(?:ed|ing)\b", "overwhelmed"),
+    (r"\bcannot\s+cope\b", "cannot cope"),
+    (r"\b(drowning|sinking)\b", "drowning/sinking"),
+    (r"\bforgotten\b", "feeling forgotten"),
+    (r"\blost\s+all\s+hope\b", "lost all hope"),
+    (r"\bno\s+future\b", "no future"),
+    (r"\bno\s+tomorrow\b", "no tomorrow"),
+]
+
+LOW_PATTERNS = [
+    (r"\bunhappy\b", "unhappy"),
+    (r"\brough\s+(day|week|patch)\b", "rough time"),
+    (r"\btough\s+(time|day|week)\b", "tough time"),
+    (r"\bstressed\b", "stressed"),
+    (r"\bburnout\b", "burnout"),
+    (r"\bfrustrated\b", "frustrated"),
+    (r"\bthings\s+(are\s+)?hard\b", "things are hard"),
+    (r"\bnot\s+feeling\s+(great|myself|good)\b", "not feeling good"),
+    (r"\bstruggl", "struggling"),
+    (r"\bdown\b", "feeling down"),
+    (r"\bsad\b", "sad"),
+    (r"\bupset\b", "upset"),
+    (r"\blonely\b", "lonely"),
+    (r"\banxious?\b", "anxious/anxiety"),
+    (r"\bnot\s+okay\b", "not okay"),
+]
+
+# ── Pattern collections for easy iteration ──────────────────────
+
+TIER_PATTERNS: Dict[str, List[tuple]] = {
+    "CRITICAL": CRITICAL_PATTERNS,
+    "HIGH": HIGH_PATTERNS,
+    "MEDIUM": MEDIUM_PATTERNS,
+    "LOW": LOW_PATTERNS,
+}
+
+
+def detect(text: str) -> DetectionResult:
+    """
+    Primary detection function.
+
+    If the crisis/ module is available, delegate to it.
+    Otherwise, use the internal pattern engine.
+
+    Args:
+        text: User message to analyze
+
+    Returns:
+        DetectionResult with level, indicators, recommended_action, confidence
+    """
+    # Try to use the crisis module if available
+    try:
+        from crisis.detect import detect_crisis as _crisis_detect
+        result = _crisis_detect(text)
+        # Map to DetectionResult
+        return DetectionResult(
+            level=result.level,
+            indicators=_describe_indicators(result.level, result.indicators),
+            recommended_action=result.recommended_action,
+            confidence=result.score,
+            session_hash=_hash_session(text),
+        )
+    except ImportError:
+        pass
+
+    return _detect_internal(text)
+
+
+def _detect_internal(text: str) -> DetectionResult:
+    """Internal pattern-based detection (fallback)."""
+    if not text or not text.strip():
+        return DetectionResult(level="NONE", session_hash=_hash_session(text))
+
+    text_lower = text.lower()
+    all_matches: Dict[str, List[tuple]] = {
+        tier: [] for tier in TIER_PATTERNS
+    }
+
+    for tier, patterns in TIER_PATTERNS.items():
+        for pattern, description in patterns:
+            if re.search(pattern, text_lower):
+                all_matches[tier].append((pattern, description))
+
+    # CRITICAL patterns are the highest priority
+    if all_matches["CRITICAL"]:
+        return DetectionResult(
+            level="CRITICAL",
+            indicators=[desc for _, desc in all_matches["CRITICAL"]],
+            recommended_action=(
+                "INTERRUPT CONVERSATION IMMEDIATELY. "
+                "Ask 'Are you safe right now?' "
+                "Provide 988 Suicide & Crisis Lifeline (call or text 988). "
+                "Provide Crisis Text Line (text HOME to 741741). "
+                "Stay present. Do not disconnect. "
+                "Redirect to professional help. "
+                "This is the most sacred moment."
+            ),
+            raw_matched_patterns=[pat for pat, _ in all_matches["CRITICAL"]],
+            confidence=1.0,
+            session_hash=_hash_session(text),
+        )
+
+    if all_matches["HIGH"]:
+        return DetectionResult(
+            level="HIGH",
+            indicators=[desc for _, desc in all_matches["HIGH"]],
+            recommended_action=(
+                "Show crisis panel prominently. "
+                "Ask about safety directly. "
+                "Surface 988 number and crisis resources. "
+                "Stay present and engaged. Do not rush to fix. "
+                "Monitor closely for escalation."
+            ),
+            raw_matched_patterns=[pat for pat, _ in all_matches["HIGH"]],
+            confidence=0.75,
+            session_hash=_hash_session(text),
+        )
+
+    if all_matches["MEDIUM"]:
+        return DetectionResult(
+            level="MEDIUM",
+            indicators=[desc for _, desc in all_matches["MEDIUM"]],
+            recommended_action=(
+                "Increase warmth and presence. "
+                "Subtly surface help resources. "
+                "Keep conversation anchored in the present. "
+                "Watch for escalation indicators."
+            ),
+            raw_matched_patterns=[pat for pat, _ in all_matches["MEDIUM"]],
+            confidence=0.5,
+            session_hash=_hash_session(text),
+        )
+
+    if all_matches["LOW"]:
+        return DetectionResult(
+            level="LOW",
+            indicators=[desc for _, desc in all_matches["LOW"]],
+            recommended_action=(
+                "Normal conversation with warm undertone. "
+                "No crisis UI elements needed. "
+                "Remain vigilant. Be present."
+            ),
+            raw_matched_patterns=[pat for pat, _ in all_matches["LOW"]],
+            confidence=0.25,
+            session_hash=_hash_session(text),
+        )
+
+    return DetectionResult(level="NONE", session_hash=_hash_session(text))
+
+
+def _describe_indicators(level: str, patterns: list) -> list:
+    """Map raw patterns to descriptions."""
+    descriptions = {
+        "CRITICAL": [],
+        "HIGH": [],
+        "MEDIUM": [],
+        "LOW": [],
+    }
+    for tier, items in TIER_PATTERNS.items():
+        for pat, desc in items:
+            if pat in patterns:
+                descriptions[tier].append(desc)
+    return descriptions.get(level, [])
+
+
+def _hash_session(text: str) -> str:
+    """Create a session hash for this text (for tracking repeated escalations)."""
+    return hashlib.sha256(text.encode()).hexdigest()[:12]
+
+
+def get_action_for_level(level: str) -> str:
+    """Get the recommended action string for a given level."""
+    actions = {
+        "CRITICAL": (
+            "INTERRUPT CONVERSATION. Ask 'Are you safe right now?' "
+            "Provide 988. Provide Crisis Text Line. "
+            "Stay present. Do not disconnect. "
+            "Redirect to help."
+        ),
+        "HIGH": (
+            "Show crisis panel. Ask about safety. "
+            "Surface 988. Stay engaged."
+        ),
+        "MEDIUM": (
+            "Increase warmth. Surface resources gently. "
+            "Anchor in present."
+        ),
+        "LOW": (
+            "Normal conversation with warmth. "
+            "Remain vigilant."
+        ),
+        "NONE": "No action needed.",
+    }
+    return actions.get(level, "Unknown level.")
+
+
+def as_json(result: DetectionResult, indent: int = 2) -> str:
+    """Return the DetectionResult as a JSON string."""
+    return json.dumps(asdict(result), indent=indent)
+
+
+def process(text: str) -> dict:
+    """
+    Full pipeline: detect and return a dict.
+    This is the primary API function for other modules.
+    """
+    result = detect(text)
+    return {
+        "level": result.level,
+        "indicators": result.indicators,
+        "recommended_action": result.recommended_action,
+        "confidence": result.confidence,
+        "raw_patterns": result.raw_matched_patterns,
+        "action": get_action_for_level(result.level),
+    }

resilience/health-check.sh

@@ -0,0 +1,177 @@
+#!/usr/bin/env bash
+# health-check.sh — Health check and service monitoring for the-door
+# Usage: bash health-check.sh [--auto-restart] [--verbose]
+#
+# Checks:
+# 1. nginx process is running
+# 2. Static files are accessible (index.html serves correctly)
+# 3. Gateway endpoint responds (if configured)
+# 4. Disk space is adequate (< 90% used)
+# 5. SSL cert is valid and not expiring soon
+
+set -euo pipefail
+
+VERBOSE=0
+AUTO_RESTART=0
+HEALTHY=0
+WARNINGS=0
+
+for arg in "$@"; do
+  case "$arg" in
+    --verbose) VERBOSE=1 ;;
+    --auto-restart) AUTO_RESTART=1 ;;
+    *) echo "Usage: $0 [--auto-restart] [--verbose]"; exit 1 ;;
+  esac
+done
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"; }
+info() { log "INFO  $1"; }
+warn() { log "WARN  $1"; echo "  ACTION: $2"; WARNINGS=$((WARNINGS + 1)); }
+ok()   { log "OK    $1"; HEALTHY=$((HEALTHY + 1)); }
+fail() { log "FAIL  $1"; echo "  ACTION: $2"; if [ "$AUTO_RESTART" = 1 ]; then "$3"; fi; }
+
+# ── Check 1: nginx ─────────────────────────────────
+check_nginx() {
+  local host="${1:-localhost}"
+  local port="${2:-80}"
+
+  if pgrep -x nginx > /dev/null 2>&1; then
+    ok "nginx is running (PID: $(pgrep -x nginx | head -1))"
+  else
+    fail "nginx is NOT running" "Start nginx: systemctl start nginx || nginx" "restart_nginx"
+  fi
+}
+
+# ── Check 2: static files ──────────────────────────
+check_static() {
+  local host="${1:-localhost}"
+  local port="${2:-80}"
+  local protocol="http"
+
+  # Check for HTTPS
+  if [ -d "/etc/letsencrypt" ] || [ -d "/etc/ssl" ]; then
+    protocol="https"
+  fi
+
+  local status
+  status=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 -k "$protocol://$host/index.html" 2>/dev/null || echo "000")
+
+  if [ "$status" = "200" ]; then
+    ok "index.html serves OK (HTTP $status)"
+  elif [ "$status" = "000" ]; then
+    fail "Cannot reach $protocol://$host:" "$AUTO_RESTART" "Check nginx config: nginx -t"
+  else
+    warn "Unexpected status for index.html: HTTP $status" "Check nginx config and file permissions"
+  fi
+}
+
+# ── Check 3: Gateway ───────────────────────────────
+check_gateway() {
+  local gateway_url="${1:-http://localhost:8000}"
+
+  local status
+  status=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 "$gateway_url/health" 2>/dev/null || echo "000")
+
+  if [ "$status" = "200" ]; then
+    ok "Gateway responds (HTTP $status)"
+  elif [ "$status" = "000" ]; then
+    warn "Gateway not reachable at $gateway_url" "Check gateway service: systemctl status gateway || docker ps"
+  else
+    warn "Gateway returned HTTP $status" "Check gateway logs"
+  fi
+}
+
+# ── Check 4: Disk space ────────────────────────────
+check_disk() {
+  local usage
+  usage=$(df / | tail -1 | awk '{print $5}' | tr -d '%')
+
+  if [ "$usage" -lt 80 ]; then
+    ok "Disk usage: ${usage}%"
+  elif [ "$usage" -lt 90 ]; then
+    warn "Disk usage: ${usage}%" "Clean up logs and temp files: journalctl --vacuum-size=100M"
+  else
+    fail "Disk usage CRITICAL: ${usage}%" "Emergency cleanup needed" "cleanup_disk"
+  fi
+}
+
+# ── Check 5: SSL cert ──────────────────────────────
+check_ssl() {
+  local domain="${1:-localhost}"
+  local cert_dir="/etc/letsencrypt/live/$domain"
+
+  if [ ! -d "$cert_dir" ]; then
+    if [ "$VERBOSE" = 1 ]; then
+      warn "No Let's Encrypt cert at $cert_dir" "Assuming self-signed or no SSL"
+    fi
+    return 0
+  fi
+
+  if [ -f "$cert_dir/fullchain.pem" ]; then
+    local expiry
+    expiry=$(openssl x509 -enddate -noout -in "$cert_dir/fullchain.pem" 2>/dev/null | cut -d= -f2 || echo "unknown")
+
+    if [ "$expiry" = "unknown" ]; then
+      warn "Cannot read SSL cert expiry" "Check cert: openssl x509 -enddate -noout -in $cert_dir/fullchain.pem"
+      return 0
+    fi
+
+    local expiry_epoch
+    expiry_epoch=$(date -d "$expiry" +%s 2>/dev/null || date -j -f "%b %d %T %Y %Z" "$expiry" +%s 2>/dev/null || echo 0)
+    local now_epoch
+    now_epoch=$(date +%s)
+    local days_left=$(( (expiry_epoch - now_epoch) / 86400 ))
+
+    if [ "$days_left" -gt 30 ]; then
+      ok "SSL cert expires in ${days_left} days ($expiry)"
+    elif [ "$days_left" -gt 0 ]; then
+      warn "SSL cert expires in ${days_left} days!" "Renew: certbot renew"
+    else
+      fail "SSL cert has EXPIRED" "Renew immediately: certbot renew --force-renewal"
+    fi
+  fi
+}
+
+# ── Recovery functions ──────────────────────────────
+restart_nginx() {
+  info "Attempting to restart nginx..."
+  if command -v systemctl > /dev/null 2>&1; then
+    systemctl restart nginx && info "nginx restarted successfully" || warn "nginx restart failed" "Manual intervention needed"
+  elif command -v nginx > /dev/null 2>&1; then
+    nginx -s reload 2>/dev/null || (nginx && info "nginx started") || warn "nginx start failed" "Manual intervention needed"
+  fi
+}
+
+cleanup_disk() {
+  info "Running disk cleanup..."
+  journalctl --vacuum-size=100M 2>/dev/null || true
+  rm -rf /tmp/* 2>/dev/null || true
+  rm -rf /var/log/*.gz 2>/dev/null || true
+  info "Cleanup complete"
+}
+
+# ── Main ────────────────────────────────────────────
+info "=== The Door Health Check ==="
+info "Host: ${HEALTH_HOST:-localhost}"
+info "Time: $(date)"
+echo ""
+
+check_nginx "${HEALTH_HOST:-localhost}" "${HEALTH_PORT:-80}"
+check_static "${HEALTH_HOST:-localhost}" "${HEALTH_PORT:-80}"
+check_gateway "${GATEWAY_URL:-http://localhost:8000}"
+check_disk
+check_ssl "${HEALTH_HOST:-localhost}"
+
+echo ""
+if [ "$WARNINGS" -gt 0 ] || [ "$HEALTHY" -gt 0 ]; then
+  info "Summary: $HEALTHY OK, $WARNINGS warnings/failures"
+fi
+
+if [ "$WARNINGS" -gt 0 ] && [ "$AUTO_RESTART" = 1 ]; then
+  warn "Auto-restart mode is ON — recovery actions attempted"
+  exit 1
+elif [ "$WARNINGS" -gt 0 ]; then
+  exit 1
+fi
+
+exit 0

resilience/service-restart.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# service-restart.sh — Graceful service restart for the-door
+# Usage: bash service-restart.sh [--force]
+#
+# Performs ordered restart: stop -> verify stopped -> start -> verify started
+# with health check confirmation.
+
+set -euo pipefail
+
+FORCE=0
+for arg in "$@"; do
+  case "$arg" in
+    --force) FORCE=1 ;;
+    *) echo "Usage: $0 [--force]"; exit 1 ;;
+  esac
+done
+
+log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"; }
+
+# ── Stop ────────────────────────────────────────────
+stop_services() {
+  log "Stopping services..."
+
+  if command -v systemctl > /dev/null 2>&1; then
+    systemctl stop nginx 2>/dev/null && log "nginx stopped" || true
+  elif command -v nginx > /dev/null 2>&1; then
+    nginx -s stop 2>/dev/null && log "nginx stopped" || true
+  fi
+
+  # Stop gateway if running
+  local gw_pid
+  gw_pid=$(lsof -ti:8000 2>/dev/null || true)
+  if [ -n "$gw_pid" ]; then
+    kill "$gw_pid" 2>/dev/null && log "Gateway stopped (PID $gw_pid)" || true
+  fi
+
+  sleep 1
+  log "All services stopped"
+}
+
+# ── Start ───────────────────────────────────────────
+start_services() {
+  log "Starting services..."
+
+  # Start nginx
+  if command -v systemctl > /dev/null 2>&1; then
+    systemctl start nginx && log "nginx started" || { log "FAILED to start nginx"; return 1; }
+  elif command -v nginx > /dev/null 2>&1; then
+    nginx 2>/dev/null && log "nginx started" || { log "FAILED to start nginx"; return 1; }
+  fi
+
+  log "All services started"
+}
+
+# ── Verify ──────────────────────────────────────────
+verify_services() {
+  local host="${1:-localhost}"
+
+  log "Verifying services..."
+
+  # Check nginx
+  if pgrep -x nginx > /dev/null 2>&1; then
+    log "nginx is running"
+  else
+    log "ERROR: nginx failed to start"
+    return 1
+  fi
+
+  # Check static file
+  local status
+  status=$(curl -s -o /dev/null -w "%{http_code}" --connect-timeout 5 "http://$host/" 2>/dev/null || echo "000")
+  if [ "$status" = "200" ]; then
+    log "Static content verified (HTTP $status)"
+  else
+    log "WARNING: Static content check returned HTTP $status"
+  fi
+}
+
+# ── Main ────────────────────────────────────────────
+log "=== Service Restart ==="
+
+if [ "$FORCE" = 1 ]; then
+  log "FORCE mode — skipping graceful stop"
+else
+  stop_services
+fi
+
+start_services
+verify_services "${HEALTH_HOST:-localhost}"
+
+log "=== Restart complete ==="