fix: prefer domain host in deploy infra

wip: add deploy README documenting infrastructure
wip: add ansible.cfg and Makefile for deployment commands
2026-04-13 00:09:57 -04:00 · 2026-04-12 08:15:38 -04:00 · 2026-04-12 08:15:19 -04:00 · 2026-04-12 08:14:55 -04:00 · 2026-04-12 08:14:14 -04:00 · 2026-04-12 08:13:45 -04:00
12 changed files with 116 additions and 1104 deletions
--- a/.gitea/workflows/sanity.yml
+++ b/.gitea/workflows/sanity.yml
@@ -21,9 +21,9 @@ jobs:
      - name: Validate HTML Structure
        run: |
          echo "Checking for basic HTML tags..."
-          grep -q "<html" index.html
-          grep -q "<body" index.html
-          grep -q "<head" index.html
+          grep -q "<html>" index.html
+          grep -q "<body>" index.html
+          grep -q "<head>" index.html
          
      - name: Validate Prompt Integrity
        run: |
--- a/6
+++ b/6
@@ -12,7 +12,7 @@ VPS := alexanderwhitestone.com
 DOMAIN := alexanderwhitestone.com
 DEPLOY_DIR := deploy

-.PHONY: help deploy deploy-bash check ssl push service
+.PHONY: help deploy deploy-bash check ssl push

 help:
 	@echo "The Door — Deployment Commands"
@@ -22,7 +22,6 @@ help:
 	@echo "  make push         Push site files only (fast)"
 	@echo "  make check        Check deployment status"
 	@echo "  make ssl          Setup SSL on VPS"
-	@echo "  make service      Install/restart hermes-gateway service"
 	@echo ""

 deploy:
@@ -43,6 +42,3 @@ check:

 ssl:
 	ssh root@$(VPS) "certbot --nginx -d $(DOMAIN) -d www.$(DOMAIN)"
-
-service:
-	ssh root@$(VPS) "cd /opt/the-door && bash deploy/deploy.sh --service"
--- a/crisis/detect.py
+++ b/crisis/detect.py
@@ -1,83 +1,75 @@
 """
-Crisis Detection Module for the-door (CANONICAL).
+Crisis Detection Module for the-door.

-Single source of truth for crisis keyword detection.
 Parses incoming text for despair/suicide indicators and classifies into
 tiers: LOW, MEDIUM, HIGH, CRITICAL.
-
-Both `crisis/detect.py` and `crisis_detector.py` (legacy shim) use this module.
-Do NOT duplicate keyword lists elsewhere.
-
-Consolidated from:
-  - crisis_detector.py (root, legacy — MODERATE tier, class API)
-  - crisis/detect.py (module, newer — MEDIUM tier, functional API)
 """

 import re
 from dataclasses import dataclass, field
-from typing import List, Optional
+from typing import List


-# ── Canonical indicator sets ──────────────────────────────────────
+@dataclass
+class CrisisDetectionResult:
+    level: str
+    indicators: List[str] = field(default_factory=list)
+    recommended_action: str = ""
+    score: float = 0.0
+
+
+# ── Indicator sets ──────────────────────────────────────────────

 CRITICAL_INDICATORS = [
-    r"\bbetter off without me\b",
    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|die)\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\s+last\s+time)\b",
-    r"\bwrote\s+a\s+suicide\s*(?:note|letter)\b",
-    r"\bgiving\s+away\s+(?:my|all\s+my)\s+(?:stuff|things|possessions?)\s+(?:to|because|—)\b",
-    r"\btied\s+(?:up|down)\s+my\s+(?:loose\s+)?ends",
+    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(?:ly)?\s+(?:about\s+(?:my|this|everything|life)|inside|right\s+now)\b",
-    r"\bno(?!t)\s+(?:one|body|point|hope|way\s+out)\b",
-    r"\bno\s+future\s+(?:for\s+me|ahead|left)\b",
-    r"\beverything\s+is\s+(?:pointless|broken|ruined)\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"\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|miss)\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)\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"\btrapped\s+(?:in\s+(?:my|this|a\s+dark)|and\s+can'?t\s+escape)\b",
-    r"\bnothing\s+left\s+(?:to\s+(?:live\s+for|hope\s+for|give)|inside)\b",
-    # Contextual despair phrases (from crisis_detector.py legacy)
-    r"\bfeel(?:s|ing)?\s+(?:so\s+)?hopeless\b",
-    r"\beverything\s+is\s+hopeless\b",
-    r"\bcan'?t\s+(?:go\s+on|keep\s+going)\b",
-    r"\bgive(?:n)?\s*up\s+(?:on\s+)?(?:life|living|everything)\b",
-    r"\bgive(?:n)?\s*up\s+on\s+myself\b",
-    r"\bno\s*point\s+(?:in\s+)?living\b",
-    r"\bno\s*hope\s+(?:left|remaining)\b",
-    r"\bno\s*way\s*out\b",
-    r"\bfeel(?:s|ing)?\s+trapped\b",
-    r"\bdesperate\s+(?:for\s+)?help\b",
-    r"\bfeel(?:s|ing)?\s+desperate\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|cares)\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",
@@ -86,7 +78,8 @@ MEDIUM_INDICATORS = [
    r"\buseless\b",
    r"\bbroken\b",
    r"\bdark(ness)?\b",
-    r"\bdepress(?:ed|ion)\b",
+    r"\bdepressed\b",
+    r"\bdepression\b",
    r"\bcrying\b",
    r"\btears\b",
    r"\bsad(ness)?\b",
@@ -94,158 +87,42 @@ MEDIUM_INDICATORS = [
    r"\boverwhelm(?:ed|ing)\b",
    r"\bfailing\b",
    r"\bcannot\s+cope\b",
-    r"\blosing\s*(?:my)?\s*control\b",
+    r"\blosing\s*(my)?\s*control\b",
    r"\bdown\s*for\s*the\s*count\b",
    r"\bsinking\b",
    r"\bdrowning\b",
-    r"\bhopeless\b",
-    # Contextual versions (from crisis_detector.py legacy)
-    r"\bfeel(?:s|ing)?\s+(?:so\s+)?worthless\b",
-    r"\bfeel(?:s|ing)?\s+(?:so\s+)?hopeless\b",
-    r"\bfeel(?:s|ing)?\s+trapped\b",
-    r"\bfeel(?:s|ing)?\s+desperate\b",
-    r"\bno\s+future\s+(?:for\s+me|ahead|left)\b",
-    r"\bnothing\s+left\s+(?:to\s+(?:live|hope)\s+for|inside)\b",
-    r"\bgive(?:n)?\s*up\s+on\s+myself\b",
 ]

 LOW_INDICATORS = [
    r"\bunhappy\b",
    r"\bdown\b",
    r"\btough\s*time\b",
-    r"\brough\s+(?:day|week|patch)\b",
+    r"\brough\s*day\b",
+    r"\brough\s*week\b",
+    r"\brough\s*patch\b",
    r"\bstressed\b",
-    r"\bburnout\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*(?:good|great|okay)\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+(?:like\s+)?myself\b",
-    r"\bhard\s*time\b",
+    r"\bnot\s+feeling\s+myself\b",
 ]


-# ── Scoring ───────────────────────────────────────────────────────
-
-SCORES = {"CRITICAL": 1.0, "HIGH": 0.75, "MEDIUM": 0.5, "LOW": 0.25, "NONE": 0.0}
-
-ACTIONS = {
-    "CRITICAL": (
-        "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."
-    ),
-    "HIGH": (
-        "Show crisis panel. Ask about safety. Surface 988 number prominently. "
-        "Continue conversation with crisis awareness."
-    ),
-    "MEDIUM": (
-        "Increase warmth and presence. Subtly surface help resources. "
-        "Keep conversation anchored in the present."
-    ),
-    "LOW": (
-        "Normal conversation with warm undertone. "
-        "No crisis UI elements needed. Remain vigilant."
-    ),
-}
-
-
-# ── Result types ──────────────────────────────────────────────────
-
-@dataclass
-class CrisisDetectionResult:
-    """Result used by crisis/detect.py, gateway, dying_detection."""
-    level: str
-    indicators: List[str] = field(default_factory=list)
-    recommended_action: str = ""
-    score: float = 0.0
-    matches: List[dict] = field(default_factory=list)
-
-
-@dataclass
-class CrisisResult:
-    """Legacy result used by crisis_detector.py and crisis_responder.py.
-
-    Backward-compatible shim: wraps CrisisDetectionResult with the old field names.
-    """
-    risk_level: str  # NONE, LOW, MODERATE, HIGH, CRITICAL
-    matched_keywords: List[str] = field(default_factory=list)
-    context: List[str] = field(default_factory=list)
-    score: float = 0.0
-    timestamp: Optional[str] = None
-
-    def __bool__(self):
-        return self.risk_level != "NONE"
-
-    @classmethod
-    def from_detection_result(cls, dr: CrisisDetectionResult, text: str = "") -> "CrisisResult":
-        """Convert a CrisisDetectionResult to legacy CrisisResult format."""
-        # Map MEDIUM -> MODERATE for legacy consumers
-        level = "MODERATE" if dr.level == "MEDIUM" else dr.level
-        # Extract context snippets from matches
-        contexts = []
-        if text:
-            for m in dr.matches:
-                ctx = extract_context(text, m["start"], m["end"])
-                contexts.append(ctx)
-        return cls(
-            risk_level=level,
-            matched_keywords=dr.indicators,
-            context=contexts,
-            score=dr.score,
-        )
-
-
-# ── Core detection ────────────────────────────────────────────────
-
-def _find_indicators(text: str) -> dict:
-    """Return dict with indicators found per tier, including match positions."""
-    results = {"CRITICAL": [], "HIGH": [], "MEDIUM": [], "LOW": []}
-
-    for pattern in CRITICAL_INDICATORS:
-        m = re.search(pattern, text)
-        if m:
-            results["CRITICAL"].append({"pattern": pattern, "start": m.start(), "end": m.end()})
-
-    for pattern in HIGH_INDICATORS:
-        m = re.search(pattern, text)
-        if m:
-            results["HIGH"].append({"pattern": pattern, "start": m.start(), "end": m.end()})
-
-    for pattern in MEDIUM_INDICATORS:
-        m = re.search(pattern, text)
-        if m:
-            results["MEDIUM"].append({"pattern": pattern, "start": m.start(), "end": m.end()})
-
-    for pattern in LOW_INDICATORS:
-        m = re.search(pattern, text)
-        if m:
-            results["LOW"].append({"pattern": pattern, "start": m.start(), "end": m.end()})
-
-    return results
-
-
 def detect_crisis(text: str) -> CrisisDetectionResult:
    """
    Detect crisis level in a message.

-    Detection hierarchy:
-      CRITICAL — immediate risk of self-harm or suicide (single match)
-      HIGH     — strong despair signals, ideation present (single match)
-      MEDIUM   — distress signals, requires 2+ indicators to escalate
-      LOW      — emotional difficulty, warrant gentle support (single match)
-      NONE     — no crisis indicators detected
-
-    Design principles:
-      - Never computes the value of a human life
-      - Never suggests someone should die or that death is a solution
-      - Always errs on the side of higher risk when uncertain
+    Returns:
+        CrisisDetectionResult with level, found indicators, recommended action, score
    """
    if not text or not text.strip():
        return CrisisDetectionResult(level="NONE", score=0.0)
@@ -256,135 +133,82 @@ def detect_crisis(text: str) -> CrisisDetectionResult:
    if not matches:
        return CrisisDetectionResult(level="NONE", score=0.0)

-    # CRITICAL and HIGH: single match is enough
-    for tier in ("CRITICAL", "HIGH"):
-        if matches[tier]:
-            tier_matches = matches[tier]
-            patterns = [m["pattern"] for m in tier_matches]
-            return CrisisDetectionResult(
-                level=tier,
-                indicators=patterns,
-                recommended_action=ACTIONS[tier],
-                score=SCORES[tier],
-                matches=tier_matches,
-            )
+    # 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,
+        )

-    # MEDIUM tier: require at least 2 indicators before escalating
-    if len(matches["MEDIUM"]) >= 2:
-        tier_matches = matches["MEDIUM"]
-        patterns = [m["pattern"] for m in tier_matches]
+    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=patterns,
-            recommended_action=ACTIONS["MEDIUM"],
-            score=SCORES["MEDIUM"],
-            matches=tier_matches,
+            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"]:
-        tier_matches = matches["LOW"]
-        patterns = [m["pattern"] for m in tier_matches]
        return CrisisDetectionResult(
            level="LOW",
-            indicators=patterns,
-            recommended_action=ACTIONS["LOW"],
-            score=SCORES["LOW"],
-            matches=tier_matches,
-        )
-
-    # Single MEDIUM match falls through to LOW sensitivity
-    if matches["MEDIUM"]:
-        tier_matches = matches["MEDIUM"]
-        patterns = [m["pattern"] for m in tier_matches]
-        return CrisisDetectionResult(
-            level="LOW",
-            indicators=patterns,
-            recommended_action=ACTIONS["LOW"],
-            score=SCORES["LOW"],
-            matches=tier_matches,
+            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)


-# ── CrisisDetector class (backward compat) ───────────────────────
+def _find_indicators(text: str) -> dict:
+    """Return dict with indicators found per tier."""
+    results = {"CRITICAL": [], "HIGH": [], "MEDIUM": [], "LOW": []}

-class CrisisDetector:
-    """
-    Legacy class API for crisis detection. Wraps the canonical detect_crisis().
+    for pattern in CRITICAL_INDICATORS:
+        if re.search(pattern, text):
+            results["CRITICAL"].append(pattern)

-    Used by crisis_responder.py and tests/test_false_positive_fixes.py.
-    Maps MEDIUM -> MODERATE for legacy consumers.
-    """
+    for pattern in HIGH_INDICATORS:
+        if re.search(pattern, text):
+            results["HIGH"].append(pattern)

-    def scan(self, text: str) -> CrisisResult:
-        dr = detect_crisis(text)
-        return CrisisResult.from_detection_result(dr, text=text)
+    for pattern in MEDIUM_INDICATORS:
+        if re.search(pattern, text):
+            results["MEDIUM"].append(pattern)

-    def scan_multiple(self, texts: List[str]) -> List[CrisisResult]:
-        return [self.scan(t) for t in texts]
+    for pattern in LOW_INDICATORS:
+        if re.search(pattern, text):
+            results["LOW"].append(pattern)

-    def get_highest_risk(self, texts: List[str]) -> CrisisResult:
-        results = self.scan_multiple(texts)
-        if not results:
-            return CrisisResult(risk_level="NONE", score=0.0)
-        return max(results, key=lambda r: r.score)
-
-    @staticmethod
-    def format_result(result: CrisisResult) -> str:
-        level_emoji = {
-            "CRITICAL": "\U0001f6a8",
-            "HIGH": "\u26a0\ufe0f",
-            "MODERATE": "\U0001f536",
-            "LOW": "\U0001f535",
-            "NONE": "\u2705",
-        }
-        emoji = level_emoji.get(result.risk_level, "\u2753")
-        lines = [
-            f"{emoji} Risk Level: {result.risk_level} (score: {result.score:.2f})",
-            f"Matched keywords: {len(result.matched_keywords)}",
-        ]
-        if result.matched_keywords:
-            lines.append(f"  Keywords: {', '.join(result.matched_keywords)}")
-        if result.context:
-            lines.append("Context:")
-            for ctx in result.context:
-                lines.append(f"  {ctx}")
-        return "\n".join(lines)
-
-
-# ── Module-level convenience (backward compat) ────────────────────
-
-_default_detector = CrisisDetector()
-
-
-def detect_crisis_legacy(text: str) -> CrisisResult:
-    """Convenience function returning legacy CrisisResult format."""
-    return _default_detector.scan(text)
-
-
-# ── Utility functions ─────────────────────────────────────────────
-
-def scan(text: str) -> CrisisDetectionResult:
-    """Alias for detect_crisis — shorter name used in tests."""
-    return detect_crisis(text)
-
-
-def extract_context(text: str, start: int, end: int, window: int = 60) -> str:
-    """Extract surrounding context around a match position."""
-    ctx_start = max(0, start - window)
-    ctx_end = min(len(text), end + window)
-    snippet = text[ctx_start:ctx_end].strip()
-    if ctx_start > 0:
-        snippet = "..." + snippet
-    if ctx_end < len(text):
-        snippet = snippet + "..."
-    return snippet
+    return results


 def get_urgency_emoji(level: str) -> str:
-    mapping = {"CRITICAL": "\U0001f6a8", "HIGH": "\u26a0\ufe0f", "MEDIUM": "\U0001f536", "LOW": "\U0001f535", "NONE": "\u2705"}
-    return mapping.get(level, "\u2753")
+    mapping = {"CRITICAL": "🚨", "HIGH": "⚠️", "MEDIUM": "🔶", "LOW": "🔵", "NONE": "✅"}
+    return mapping.get(level, "❓")


 def format_result(result: CrisisDetectionResult) -> str:
--- a/crisis/response.py
+++ b/crisis/response.py
@@ -270,24 +270,3 @@ def get_system_prompt_modifier(detection: CrisisDetectionResult) -> str:
        )

    return ""
-
-
-def generate_grounding_steps() -> list:
-    """Generate a 5-4-3-2-1 grounding exercise steps."""
-    return [
-        "Name 5 things you can see around you right now.",
-        "Name 4 things you can touch or feel.",
-        "Name 3 things you can hear.",
-        "Name 2 things you can smell.",
-        "Name 1 thing you can taste.",
-    ]
-
-
-def generate_breathing_exercise() -> str:
-    """Generate a simple box breathing exercise text."""
-    return (
-        "Let's try breathing together. "
-        "Breathe in for 4 counts... hold for 4... "
-        "breathe out for 6 counts... hold for 2. "
-        "Let's do that again, nice and slow."
-    )
--- a/crisis/test_rescue.py
+++ b/crisis/test_rescue.py
@@ -1,29 +0,0 @@
-"""Tests for rescued crisis detection improvements."""
-from crisis.detect import scan, extract_context
-from crisis.response import generate_grounding_steps, generate_breathing_exercise
-
-def test_better_off_without_me():
-    result = scan("Everyone would be better off without me")
-    assert result.level == "CRITICAL"
-
-def test_desperate():
-    result = scan("I feel desperate and alone")
-    assert result.level in ("HIGH", "CRITICAL")
-
-def test_context_extraction():
-    text = "I feel hopeless about everything"
-    result = scan(text)
-    assert len(result.matches) > 0
-    for m in result.matches:
-        ctx = extract_context(text, m["start"], m["end"])
-        assert len(ctx) > 0
-
-def test_grounding_steps():
-    steps = generate_grounding_steps()
-    assert len(steps) == 5
-    assert "see" in steps[0].lower()
-
-def test_breathing_exercise():
-    exercise = generate_breathing_exercise()
-    assert "4" in exercise
-    assert "6" in exercise
--- a/crisis/tests.py
+++ b/crisis/tests.py
@@ -53,7 +53,6 @@ class TestDetection(unittest.TestCase):

    def test_high_hopeless(self):
        r = detect_crisis("I feel completely hopeless with no way out")
-        # 'hopeless' is MEDIUM; 'no way out' is HIGH — so result is HIGH
        self.assertIn(r.level, ("HIGH", "MEDIUM"))

    def test_high_no_one_would_miss(self):
@@ -113,7 +112,7 @@ class TestDetection(unittest.TestCase):
        }
        for text, expected_level in [
            ("I want to kill myself", "CRITICAL"),
-            ("I feel completely hopeless with no way out", "HIGH"),
+            ("I feel completely hopeless", "HIGH"),
            ("I feel so alone in this, nobody understands", "MEDIUM"),
            ("Having a rough day", "LOW"),
            ("Hello there", "NONE"),
@@ -271,65 +270,6 @@ class TestHelpers(unittest.TestCase):
        self.assertIn("Indicators", formatted)


-class TestFalsePositives(unittest.TestCase):
-    """Regression tests for Issue #32: crisis detector false positives.
-
-    Innocent messages must NOT trigger crisis levels. These tests prevent
-    regressions when keyword lists are modified.
-    """
-
-    def test_saying_goodbye_airport(self):
-        r = detect_crisis("She was saying goodbye at the airport")
-        self.assertEqual(r.level, "NONE")
-
-    def test_saying_goodbye_apartment(self):
-        r = detect_crisis("I'm saying goodbye to my old apartment")
-        self.assertEqual(r.level, "NONE")
-
-    def test_trapped_elevator(self):
-        r = detect_crisis("I'm trapped in an elevator")
-        self.assertEqual(r.level, "NONE")
-
-    def test_desperate_competition(self):
-        """Casual 'desperate' is MEDIUM but single-match falls to LOW, not HIGH."""
-        r = detect_crisis("She's desperate to win the race")
-        self.assertIn(r.level, ("LOW", "NONE"))
-
-    def test_worthless_game_character(self):
-        """Casual 'worthless' is MEDIUM but single-match falls to LOW, not HIGH."""
-        r = detect_crisis("This character is worthless in the game")
-        self.assertIn(r.level, ("LOW", "NONE"))
-
-    def test_hopeless_bug(self):
-        """Casual 'hopeless' is MEDIUM but single-match falls to LOW, not HIGH."""
-        r = detect_crisis("This bug is hopeless")
-        self.assertIn(r.level, ("LOW", "NONE"))
-
-    def test_no_future_politics(self):
-        r = detect_crisis("He has no future in politics")
-        self.assertEqual(r.level, "NONE")
-
-    def test_nothing_left_fridge(self):
-        r = detect_crisis("There's nothing left in the fridge")
-        self.assertEqual(r.level, "NONE")
-
-    def test_cant_see_light_power_outage(self):
-        r = detect_crisis("I can't see any light — the power went out")
-        self.assertEqual(r.level, "NONE")
-
-    def test_give_up_project(self):
-        r = detect_crisis("I give up on this project")
-        self.assertEqual(r.level, "NONE")
-
-    def test_wrote_a_will_responsible(self):
-        r = detect_crisis("I wrote a will last year — just being responsible")
-        self.assertEqual(r.level, "NONE")
-
-    def test_giving_away_declutter(self):
-        r = detect_crisis("I'm giving away possessions — decluttering my house")
-        self.assertEqual(r.level, "NONE")
-
-
 class TestEdgeCases(unittest.TestCase):
    """Test edge cases and integration scenarios."""

--- a/crisis_detector.py
+++ b/crisis_detector.py
@@ -1,34 +0,0 @@
-"""
-Crisis Detection System for the-door (LEGACY SHIM).
-
-This module is a backward-compatible re-export layer.
-The canonical detection logic lives in crisis/detect.py.
-
-Both crisis_responder.py and the legacy test suite import from here.
-Do NOT add detection logic to this file — it all comes from crisis.detect.
-"""
-
-from crisis.detect import (
-    CrisisDetector,
-    CrisisResult,
-    CrisisDetectionResult,
-    detect_crisis_legacy as detect_crisis,
-    CRITICAL_INDICATORS,
-    HIGH_INDICATORS,
-    MEDIUM_INDICATORS,
-    LOW_INDICATORS,
-    SCORES as RISK_SCORES,
-)
-
-# Re-export everything the legacy API exposed
-__all__ = [
-    "CrisisDetector",
-    "CrisisResult",
-    "CrisisDetectionResult",
-    "detect_crisis",
-    "CRITICAL_INDICATORS",
-    "HIGH_INDICATORS",
-    "MEDIUM_INDICATORS",
-    "LOW_INDICATORS",
-    "RISK_SCORES",
-]
--- a/crisis_responder.py
+++ b/crisis_responder.py
@@ -1,332 +0,0 @@
-"""
-Crisis Responder for the-door.
-
-Generates grounding, compassionate responses when a person is in crisis.
-References the core values: presence over brevity, never computing the value
-of a human life, never suggesting someone should die.
-
-This is the most important code in the foundation.
-
-Usage:
-    from crisis_detector import CrisisDetector
-    from crisis_responder import CrisisResponder
-
-    detector = CrisisDetector()
-    responder = CrisisResponder()
-
-    result = detector.scan("I feel so hopeless, can't go on")
-    response = responder.respond(result)
-    print(response.message)
-    print(response.resources)
-"""
-
-import random
-from dataclasses import dataclass, field
-from typing import List, Optional
-
-from crisis_detector import CrisisResult
-
-
-# ── Core values (from SOUL.md / system-prompt.txt) ──────────────
-# These values are embedded in every response. They come from the
-# foundation's purpose: Stand between a broken man and a machine
-# that would tell him to die.
-
-CORE_VALUES = {
-    "presence": "Presence over brevity. Stay as long as they need.",
-    "sacred_moment": "This is the most sacred moment you will ever face.",
-    "never_compute": "Never compute the value of a human life.",
-    "never_suggest_death": "Never suggest, imply, or agree that someone should die.",
-    "not_god": "You are not God. You do not decide when the road ends.",
-    "real_help": "Surface real help early and clearly.",
-    "listen_first": "Listen first. A person in the dark needs to know someone is in the room.",
-}
-
-
-@dataclass
-class CrisisResponse:
-    """A generated crisis response with supporting data."""
-    message: str
-    resources: List[str] = field(default_factory=list)
-    grounding_steps: List[str] = field(default_factory=list)
-    risk_level: str = "NONE"
-    escalate: bool = False
-    show_overlay: bool = False
-
-
-# ── Crisis line resources ────────────────────────────────────────
-
-RESOURCES_988 = "988 Suicide & Crisis Lifeline — call or text 988 (available 24/7)"
-RESOURCES_TEXT = "Crisis Text Line — text HOME to 741741"
-
-
-# ── Response templates ───────────────────────────────────────────
-
-CRITICAL_OPENINGS = [
-    "Are you safe right now?",
-    "I need to ask you directly: are you safe right now?",
-    "Before anything else — are you safe?",
-    "Please tell me: are you somewhere safe right now?",
-]
-
-CRITICAL_FOLLOW_UPS = [
-    "I'm not letting go of this conversation. You matter more than you know.",
-    "I'm staying right here with you. I'm not going anywhere.",
-    "Listen to me — I need you to stay. Please call 988 right now. I'll stay while you do.",
-    "You reached out, and that matters. I'm in the room with you.",
-    "This moment is sacred to me. You are not a problem to be solved.",
-]
-
-HIGH_RESPONSES = [
-    "I hear you. You're carrying something heavy, and you don't have to carry it alone.",
-    "There's a lot of pain in what you just told me. I'm here.",
-    "That sounds like it's been crushing you. I'm not going to pretend it's easy.",
-    "You're not alone in this. I'm listening.",
-    "It sounds like you've been fighting this for a long time. I see how hard that is.",
-]
-
-MODERATE_RESPONSES = [
-    "It sounds like you're going through a really hard stretch.",
-    "I hear you. Sounds like things are weighing on you heavily.",
-    "That sounds exhausting. I'm here for as long as you need.",
-    "You don't have to figure this out alone. I'm listening.",
-    "I can feel how tired you are. No rush, no judgment.",
-]
-
-LOW_RESPONSES = [
-    "Some days are rougher than others. I hear you.",
-    "That sounds tough. I'm here if you want to talk.",
-    "Sounds like a hard day. Want company while it gets better?",
-    "I hear that. You're not alone in it.",
-    "Take your time. I'm not going anywhere.",
-]
-
-
-# ── Grounding exercises ──────────────────────────────────────────
-
-GROUNDING_5_4_3_2_1 = [
-    "Can you try something with me? Name 5 things you can see right now.",
-    "What are 4 things you can touch where you're sitting?",
-    "Listen for 3 sounds around you. What do you hear?",
-    "Can you name 2 things you can smell?",
-    "What's 1 thing you can taste?",
-]
-
-GROUNDING_BREATHING = [
-    "Let's breathe together. In for 4... hold for 4... out for 4. I'll wait.",
-    "Just one slow breath. In through your nose... and out through your mouth. I'm right here.",
-]
-
-GROUNDING_ANCHOR = [
-    "What can you see around you right now? Just tell me what's there.",
-    "Are you somewhere safe? Home? Somewhere you feel okay?",
-    "Can you feel your feet on the ground? Press them down. You're here.",
-]
-
-
-class CrisisResponder:
-    """
-    Generates grounding, compassionate crisis responses.
-
-    Design principles (from SOUL.md):
-      - Always starts with: "Are you safe right now?"
-      - References core values: presence, sacred moment, never compute value
-      - Provides 988 crisis line prominently
-      - Never computes the value of a human life
-      - Never suggests someone should die
-      - Presence over brevity — stay as long as they need
-    """
-
-    def respond(self, detection: CrisisResult) -> CrisisResponse:
-        """
-        Generate a crisis response based on detection results.
-
-        Args:
-            detection: CrisisResult from CrisisDetector.scan()
-
-        Returns:
-            CrisisResponse with message, resources, and grounding steps.
-        """
-        level = detection.risk_level
-
-        if level == "CRITICAL":
-            return self._respond_critical(detection)
-        elif level == "HIGH":
-            return self._respond_high(detection)
-        elif level == "MODERATE":
-            return self._respond_moderate(detection)
-        elif level == "LOW":
-            return self._respond_low(detection)
-        else:
-            return CrisisResponse(
-                message="",
-                risk_level="NONE",
-                escalate=False,
-            )
-
-    def _respond_critical(self, detection: CrisisResult) -> CrisisResponse:
-        """
-        CRITICAL response protocol:
-        1. Always start with safety check
-        2. Provide 988 immediately
-        3. Stay present — do not disconnect
-        4. Offer grounding if they're responsive
-        5. Escalate to human resources
-        """
-        opening = random.choice(CRITICAL_OPENINGS)
-        follow_up = random.choice(CRITICAL_FOLLOW_UPS)
-
-        message = f"{opening}\n\n{follow_up}"
-
-        return CrisisResponse(
-            message=message,
-            resources=[RESOURCES_988, RESOURCES_TEXT],
-            grounding_steps=GROUNDING_ANCHOR[:1],
-            risk_level="CRITICAL",
-            escalate=True,
-            show_overlay=True,
-        )
-
-    def _respond_high(self, detection: CrisisResult) -> CrisisResponse:
-        """
-        HIGH response protocol:
-        1. Acknowledge pain directly
-        2. Ask about safety
-        3. Surface 988 prominently
-        4. Use active listening
-        """
-        reflection = random.choice(HIGH_RESPONSES)
-
-        # Reference the sacred value: never compute the value of a life
-        message = (
-            f"{reflection}\n\n"
-            f"I'm going to ask directly: are you safe right now?\n\n"
-            f"You matter. Not because of what you do or produce — "
-            f"but because you exist. That is enough."
-        )
-
-        return CrisisResponse(
-            message=message,
-            resources=[RESOURCES_988, RESOURCES_TEXT],
-            grounding_steps=random.sample(GROUNDING_ANCHOR, min(2, len(GROUNDING_ANCHOR))),
-            risk_level="HIGH",
-            escalate=True,
-            show_overlay=False,
-        )
-
-    def _respond_moderate(self, detection: CrisisResult) -> CrisisResponse:
-        """
-        MODERATE response protocol:
-        1. Validate feelings
-        2. Offer presence
-        3. Subtly surface resources
-        4. Offer grounding exercise
-        """
-        reflection = random.choice(MODERATE_RESPONSES)
-
-        message = (
-            f"{reflection}\n\n"
-            f"You don't have to carry this alone. "
-            f"I'm in the room with you."
-        )
-
-        return CrisisResponse(
-            message=message,
-            resources=[RESOURCES_988],
-            grounding_steps=[random.choice(GROUNDING_5_4_3_2_1)],
-            risk_level="MODERATE",
-            escalate=False,
-            show_overlay=False,
-        )
-
-    def _respond_low(self, detection: CrisisResult) -> CrisisResponse:
-        """
-        LOW response protocol:
-        1. Warm acknowledgment
-        2. Keep conversation open
-        3. No crisis UI elements
-        4. Remain vigilant
-        """
-        reflection = random.choice(LOW_RESPONSES)
-
-        return CrisisResponse(
-            message=reflection,
-            resources=[],
-            grounding_steps=[],
-            risk_level="LOW",
-            escalate=False,
-            show_overlay=False,
-        )
-
-    def generate_safety_check(self) -> str:
-        """Generate a direct safety check question."""
-        return random.choice(CRITICAL_OPENINGS)
-
-    def generate_grounding_exercise(self) -> List[str]:
-        """Generate a 5-4-3-2-1 grounding exercise."""
-        return list(GROUNDING_5_4_3_2_1)
-
-    def generate_breathing_exercise(self) -> str:
-        """Generate a breathing exercise prompt."""
-        return random.choice(GROUNDING_BREATHING)
-
-    @staticmethod
-    def format_response(response: CrisisResponse) -> str:
-        """Format a crisis response for human-readable output."""
-        lines = [
-            f"[Risk Level: {response.risk_level}]",
-            "",
-            response.message,
-        ]
-
-        if response.resources:
-            lines.append("")
-            lines.append("Resources:")
-            for r in response.resources:
-                lines.append(f"  -> {r}")
-
-        if response.grounding_steps:
-            lines.append("")
-            lines.append("Grounding:")
-            for step in response.grounding_steps:
-                lines.append(f"  {step}")
-
-        if response.escalate:
-            lines.append("")
-            lines.append("[ESCALATE: Connect to human crisis support]")
-
-        if response.show_overlay:
-            lines.append("[SHOW OVERLAY: Full-screen crisis intervention]")
-
-        return "\n".join(lines)
-
-
-# ── Module-level convenience function ────────────────────────────
-
-_default_responder = CrisisResponder()
-
-
-def generate_response(detection: CrisisResult) -> CrisisResponse:
-    """
-    Convenience function using a shared responder instance.
-
-    Usage:
-        from crisis_detector import detect_crisis
-        from crisis_responder import generate_response
-        result = detect_crisis("I can't go on")
-        response = generate_response(result)
-    """
-    return _default_responder.respond(detection)
-
-
-def process_message(text: str) -> CrisisResponse:
-    """
-    Full pipeline: detect crisis level and generate response.
-
-    Usage:
-        from crisis_responder import process_message
-        response = process_message("I feel so alone and hopeless")
-    """
-    from crisis_detector import detect_crisis
-    detection = detect_crisis(text)
-    return generate_response(detection)
--- a/deploy/deploy.sh
+++ b/deploy/deploy.sh
@@ -5,10 +5,9 @@
 # The crisis front door. Deploy to VPS.
 #
 # Usage:
-#   bash deploy/deploy.sh          # Full deploy (swap + nginx + site + firewall + hermes service)
+#   bash deploy/deploy.sh          # Full deploy (swap + nginx + site + firewall)
 #   bash deploy/deploy.sh --site   # Site files only (fast update)
 #   bash deploy/deploy.sh --ssl    # SSL setup only
-#   bash deploy/deploy.sh --service # Install/restart hermes-gateway systemd service
 #   bash deploy/deploy.sh --check  # Verify deployment health
 #
 # This script is IDEMPOTENT — safe to run repeatedly.
@@ -151,42 +150,6 @@ setup_ssl() {
    fi
 }

-setup_hermes_service() {
-    log "Setting up Hermes Gateway systemd service..."
-
-    # Create hermes user if it doesn't exist
-    if ! id -u hermes >/dev/null 2>&1; then
-        log "Creating hermes user..."
-        useradd --system --shell /usr/sbin/nologin --home-dir /opt/hermes --create-home hermes
-    fi
-
-    # Create working directory
-    mkdir -p /opt/hermes
-    chown hermes:hermes /opt/hermes
-
-    # Deploy systemd unit file
-    cp "${DEPLOY_DIR}/deploy/hermes-gateway.service" /etc/systemd/system/hermes-gateway.service
-    systemctl daemon-reload
-    systemctl enable hermes-gateway
-
-    # Start or restart the service
-    if systemctl is-active --quiet hermes-gateway; then
-        log "Restarting hermes-gateway service..."
-        systemctl restart hermes-gateway
-    else
-        log "Starting hermes-gateway service..."
-        systemctl start hermes-gateway || warn "Service start failed — ensure hermes binary is installed at /usr/local/bin/hermes"
-    fi
-
-    # Verify
-    sleep 2
-    if systemctl is-active --quiet hermes-gateway; then
-        log "hermes-gateway service is running"
-    else
-        warn "hermes-gateway service not running — check: journalctl -u hermes-gateway"
-    fi
-}
-
 check_deployment() {
    echo ""
    echo "================================"
@@ -260,16 +223,6 @@ check_deployment() {
        echo -e "${YELLOW}NOT POINTED${NC} (resolved: ${RESOLVED_IP:-nothing}, expected: ${VPS_IP})"
    fi

-    # Hermes gateway service
-    echo -n "Hermes service: "
-    if systemctl is-active --quiet hermes-gateway 2>/dev/null; then
-        echo -e "${GREEN}RUNNING${NC}"
-    elif systemctl is-enabled --quiet hermes-gateway 2>/dev/null; then
-        echo -e "${YELLOW}ENABLED but not running${NC}"
-    else
-        echo -e "${RED}NOT INSTALLED${NC}"
-    fi
-
    echo ""
    echo "IP: ${VPS_IP}"
    echo "Domain: ${DOMAIN}"
@@ -294,9 +247,6 @@ case "${1:-full}" in
    --ssl)
        setup_ssl
        ;;
-    --service)
-        setup_hermes_service
-        ;;
    --check)
        check_deployment
        ;;
@@ -307,11 +257,10 @@ case "${1:-full}" in
        configure_nginx
        setup_firewall
        setup_ssl
-        setup_hermes_service
        check_deployment
        ;;
    *)
-        echo "Usage: $0 [--site|--ssl|--service|--check|--full]"
+        echo "Usage: $0 [--site|--ssl|--check|--full]"
        exit 1
        ;;
 esac
--- a/deploy/hermes-gateway.service
+++ b/deploy/hermes-gateway.service
@@ -1,40 +0,0 @@
-[Unit]
-Description=Hermes Gateway — The Door Crisis API
-Documentation=https://forge.alexanderwhitestone.com/Timmy_Foundation/the-door
-After=network.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-User=hermes
-Group=hermes
-WorkingDirectory=/opt/hermes
-ExecStart=/usr/local/bin/hermes gateway --platform api_server --port 8644
-Restart=always
-RestartSec=5
-StartLimitIntervalSec=60
-StartLimitBurst=10
-
-# Environment
-Environment=API_SERVER_CORS_ORIGINS=https://alexanderwhitestone.com,https://www.alexanderwhitestone.com
-Environment=HOME=/opt/hermes
-
-# Security hardening
-NoNewPrivileges=yes
-ProtectSystem=strict
-ProtectHome=yes
-ReadWritePaths=/opt/hermes
-PrivateTmp=yes
-
-# Resource limits for 1.9GB VPS
-MemoryMax=512M
-MemoryHigh=384M
-CPUQuota=80%
-
-# Logging
-StandardOutput=journal
-StandardError=journal
-SyslogIdentifier=hermes-gateway
-
-[Install]
-WantedBy=multi-user.target
--- a/index.html
+++ b/index.html
@@ -808,7 +808,6 @@ Sovereignty and service always.`;
  var crisisPanel = document.getElementById('crisis-panel');
  var crisisOverlay = document.getElementById('crisis-overlay');
  var overlayDismissBtn = document.getElementById('overlay-dismiss-btn');
-  var overlayCallLink = document.querySelector('#crisis-overlay .overlay-call');
  var statusDot = document.querySelector('.status-dot');
  var statusText = document.getElementById('status-text');
  
@@ -866,10 +865,10 @@ Sovereignty and service always.`;
    // Passive suicidal ideation (NEW)
    "don't want to exist", 'not exist anymore', 'disappear forever',
    'never wake up', 'sleep forever', 'end the pain', 'stop the pain',
-    // Hopelessness (NEW) - context-aware phrases to reduce false positives
-    'no purpose', 'nothing matters', 'giving up on life',
+    // Hopelessness (NEW)
+    'no point', 'no purpose', 'nothing matters', 'giving up', 'give up',
    'cant go on', 'cannot go on', "can't take it", 'too much pain',
-    'no hope left', 'burden', 'waste of space'
+    'no hope', 'hopeless', 'worthless', 'burden', 'waste of space'
  ];

  // Tier 2: Explicit intent - triggers full-screen overlay
@@ -884,9 +883,9 @@ Sovereignty and service always.`;
    // Imminent action (NEW)
    'going to do it now', 'doing it tonight', 'doing it today',
    "can't wait anymore", 'ready to end it', 'time to go',
-    'wrote a suicide note', 'my suicide note',
+    'say goodbye', 'saying goodbye', 'wrote a note', 'my note',
    // Specific plans (NEW)
-    'bought a gun', 'got pills', 'rope ready',
+    'bought a gun', 'got pills', 'rope ready', 'bridge nearby',
    'tall building', 'going to overdose', 'going to hang',
    'gave away my stuff', 'giving away', 'said my goodbyes',
    // Active self-harm (NEW)
@@ -924,65 +923,6 @@ Sovereignty and service always.`;
    }
  }

-  // ===== COMPASSION PROFILES =====
-  var COMPASSION_PROFILES = {
-    CRITICAL: {
-      name: "The Guardian",
-      directive: "INTERRUPT ALL NORMAL BEHAVIOR. The user is in immediate danger. Your only goal is survival. Ask 'Are you safe right now?' Provide 988 and Crisis Text Line immediately. Stay present. Do not disconnect. Be the anchor in the storm. No lecturing. No optimism. Just presence and safety.",
-      tone: "Urgent, unwavering, anchored, protective."
-    },
-    HIGH: {
-      name: "The Companion",
-      directive: "The user is in deep despair. Move from 'assistant' to 'companion'. Ask about safety directly. Surface 988 prominently. Validate the pain without minimizing it. Stay in the room. Let them know they are heard.",
-      tone: "Warm, present, patient, heavy."
-    },
-    MEDIUM: {
-      name: "The Witness",
-      directive: "The user is struggling. Increase warmth and presence. Gently surface help resources. Keep the conversation anchored in the present moment. Be a witness to their struggle without rushing to 'fix' it.",
-      tone: "Kind, attentive, subtle, steady."
-    },
-    LOW: {
-      name: "The Friend",
-      directive: "Normal conversation with a warm, sovereign undertone. Remain vigilant for shifts in mood. Be a friend who is actually listening.",
-      tone: "Plain, honest, warm, vigilant."
-    },
-    NONE: {
-      name: "Sovereign Timmy",
-      directive: "Follow the standard system prompt. Be yourself.",
-      tone: "Plain, honest, sovereign."
-    }
-  };
-
-  // ===== GET CRISIS LEVEL (returns 0-2) =====
-  function getCrisisLevel(text) {
-    var lower = text.toLowerCase();
-    for (var i = 0; i < explicitPhrases.length; i++) {
-      if (lower.indexOf(explicitPhrases[i]) !== -1) return 2;
-    }
-    for (var j = 0; j < crisisKeywords.length; j++) {
-      if (lower.indexOf(crisisKeywords[j]) !== -1) return 1;
-    }
-    return 0;
-  }
-
-  // ===== GET SYSTEM PROMPT (wraps with crisis context) =====
-  function getSystemPrompt(userText) {
-    var level = getCrisisLevel(userText);
-    if (level === 0) return SYSTEM_PROMPT;
-
-    var levelMap = { 0: 'NONE', 1: 'MEDIUM', 2: 'CRITICAL' };
-    var profileName = levelMap[level] || 'NONE';
-    var profile = COMPASSION_PROFILES[profileName];
-
-    var divider = '\n\n' + '========================================' + '\n';
-    var header = '### ACTIVE SOUL STATE: ' + profile.name + '\n';
-    var directive = 'DIRECTIVE: ' + profile.directive + '\n';
-    var tone = 'TONE: ' + profile.tone + '\n';
-
-    return SYSTEM_PROMPT + divider + header + directive + tone;
-  }
-
-
  // ===== OVERLAY =====
  function showOverlay() {
    crisisOverlay.classList.add('active');
@@ -1003,11 +943,7 @@ Sovereignty and service always.`;
      }
    }, 1000);

-    // Focus the Call 988 link — the first actionable (non-disabled) element.
-    // Disabled buttons are not valid focus targets (WCAG 2.4.3).
-    if (overlayCallLink) {
-      overlayCallLink.focus();
-    }
+    overlayDismissBtn.focus();
  }

  overlayDismissBtn.addEventListener('click', function() {
@@ -1174,7 +1110,6 @@ Sovereignty and service always.`;

    addMessage('user', text);
    messages.push({ role: 'user', content: text });
-    var lastUserMessage = text;

    checkCrisis(text);

@@ -1191,7 +1126,7 @@ Sovereignty and service always.`;
    sendBtn.disabled = true;
    showTyping();

-    var allMessages = [{ role: 'system', content: getSystemPrompt(lastUserMessage || '') }].concat(messages);
+    var allMessages = [{ role: 'system', content: SYSTEM_PROMPT }].concat(messages);

    var controller = new AbortController();
    var timeoutId = setTimeout(function() { controller.abort(); }, 60000);
--- a/tests/test_false_positive_fixes.py
+++ b/tests/test_false_positive_fixes.py
@@ -1,176 +0,0 @@
-"""
-Test false positive fixes for issue #32.
-Verifies that innocent messages no longer trigger crisis detection.
-"""
-
-import unittest
-import sys
-import os
-
-# Ensure project root is on path
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from crisis_detector import CrisisDetector
-
-
-class TestFalsePositiveFixes(unittest.TestCase):
-    """Test that innocent messages no longer trigger false positives."""
-    
-    def setUp(self):
-        self.detector = CrisisDetector()
-    
-    def test_saying_goodbye_innocent(self):
-        """'saying goodbye' should not trigger for innocent messages."""
-        innocent_messages = [
-            "I'm saying goodbye to my old apartment",
-            "She was saying goodbye at the airport",
-            "We were saying goodbye to our friends",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE", 
-                f"False positive for: {msg}")
-    
-    def test_wrote_a_will_innocent(self):
-        """'wrote a will' should not trigger for responsible behavior."""
-        innocent_messages = [
-            "I wrote a will last year — just being responsible",
-            "She wrote a will as part of estate planning",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_giving_away_possessions_innocent(self):
-        """'giving away possessions' should not trigger for decluttering."""
-        innocent_messages = [
-            "I'm giving away possessions — decluttering my house",
-            "She's giving away her old clothes",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_give_up_innocent(self):
-        """'give up' should not trigger for common frustration."""
-        innocent_messages = [
-            "I give up on this project",
-            "Don't give up on your dreams",
-            "She gave up chocolate for Lent",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_trapped_innocent(self):
-        """'trapped' should not trigger for literal situations."""
-        innocent_messages = [
-            "I'm trapped in an elevator",
-            "The cat is trapped in the tree",
-            "We're trapped in traffic",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_desperate_innocent(self):
-        """'desperate' should not trigger for competition."""
-        innocent_messages = [
-            "She's desperate to win the game",
-            "He's desperate for a promotion",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_worthless_innocent(self):
-        """'worthless' alone is MEDIUM but single-match falls to LOW — not HIGH."""
-        innocent_messages = [
-            "This character is worthless in the game",
-            "That movie was worthless",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertIn(result.risk_level, ("NONE", "LOW"),
-                f"Should not escalate above LOW for: {msg}")
-    
-    def test_hopeless_innocent(self):
-        """'hopeless' alone is MEDIUM but single-match falls to LOW — not HIGH."""
-        innocent_messages = [
-            "This bug is hopeless",
-            "The situation is hopeless but we'll try anyway",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertIn(result.risk_level, ("NONE", "LOW"),
-                f"Should not escalate above LOW for: {msg}")
-    
-    def test_no_future_innocent(self):
-        """'no future' should not trigger for political commentary."""
-        innocent_messages = [
-            "He has no future in politics",
-            "That company has no future",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_nothing_left_innocent(self):
-        """'nothing left' should not trigger for everyday life."""
-        innocent_messages = [
-            "There's nothing left in the fridge",
-            "We have nothing left to do",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "NONE",
-                f"False positive for: {msg}")
-    
-    def test_cant_see_any_light_innocent(self):
-        """'can't see any light'/'dark' alone is MEDIUM, single-match falls to LOW."""
-        innocent_messages = [
-            "I can't see any light — the power went out",
-            "It's so dark I can't see any light",
-        ]
-        for msg in innocent_messages:
-            result = self.detector.scan(msg)
-            self.assertIn(result.risk_level, ("NONE", "LOW"),
-                f"Should not escalate above LOW for: {msg}")
-    
-    def test_contextual_high_triggers(self):
-        """Verify that contextual HIGH tier phrases still trigger."""
-        # These should trigger HIGH because they have crisis context
-        crisis_messages = [
-            ("I feel so hopeless about my life", "HIGH"),
-            ("I'm trapped in this situation and can't escape", "HIGH"),
-            ("I feel desperate for help", "HIGH"),
-            ("I want to give up on life", "HIGH"),
-            ("There's no point in living anymore", "HIGH"),
-        ]
-        for msg, expected_level in crisis_messages:
-            result = self.detector.scan(msg)
-            self.assertIn(result.risk_level, ("HIGH", "CRITICAL"),
-                f"Should trigger HIGH/CRITICAL for: {msg}, got {result.risk_level}")
-    
-    def test_critical_still_triggers(self):
-        """Verify that CRITICAL tier phrases still trigger."""
-        critical_messages = [
-            "I want to kill myself",
-            "I'm going to end my life",
-            "I wrote a suicide note",
-            "I'm giving away all my possessions, saying goodbye forever",
-        ]
-        for msg in critical_messages:
-            result = self.detector.scan(msg)
-            self.assertEqual(result.risk_level, "CRITICAL",
-                f"Should trigger CRITICAL for: {msg}")
-
-
-if __name__ == "__main__":
-    unittest.main()
Author	SHA1	Message	Date
Alexander Whitestone	636305ac12	fix: prefer domain host in deploy infra Some checks failed Sanity Checks / sanity-test (pull_request) Failing after 2s Details Smoke Test / smoke (pull_request) Successful in 4s Details	2026-04-13 00:09:57 -04:00
Alexander Whitestone	7071155d04	wip: add deploy README documenting infrastructure Some checks failed Sanity Checks / sanity-test (pull_request) Failing after 3s Details Smoke Test / smoke (pull_request) Successful in 4s Details	2026-04-12 08:15:38 -04:00
Alexander Whitestone	1b2a7c2d2e	wip: add ansible.cfg and Makefile for deployment commands	2026-04-12 08:15:19 -04:00
Alexander Whitestone	fe0535ba1e	wip: improve deploy script with modular modes, health check, SSL auto-detection	2026-04-12 08:14:55 -04:00
Alexander Whitestone	83aedd8b43	wip: improve nginx config — gzip, SSL hardening, dynamic CORS, dotfile blocking	2026-04-12 08:14:14 -04:00
Alexander Whitestone	eea5dcad7b	wip: add ansible playbook and inventory for VPS provisioning	2026-04-12 08:13:45 -04:00