feat: add Timmy crisis detector module (#791)

docs/UNIFIED_FLEET_SOVEREIGNTY_STATUS.md

@@ -1,107 +0,0 @@
-# [DIRECTIVE] Unified Fleet Sovereignty & Comms Migration
-
-Grounding report for `timmy-home #524`.
-
-Issue #524 is a multi-lane directive, not a one-commit feature. This report grounds the directive in repo evidence, highlights stale cross-links, and names the missing operator bundles that still need real execution.
-
-This remains a `Refs #524` artifact. The directive spans multiple repos and operator actions, so this report makes the current repo-side state executable without pretending the whole migration is complete.
-
-## Directive Snapshot
-
-- Repo-grounded workstreams: 0
-- Partial workstreams: 4
-- Missing workstreams: 1
-- Drifted references: 4
-
-## Reference Drift
-
-- #813 is cited for Nostr Migration Leadership, but its current title is 'docs: refresh the-playground genome analysis (#671)'.
-- #819 is cited for Nostr Migration Leadership, but its current title is 'docs: verify #648 already implemented (closes #818)'.
-- #139 is cited for v0.7.0 Feature Audit, but its current title is '🐣 Allegro-Primus is born'.
-- #103 is cited for Morrowind Local-First Benchmark, but its current title is 'Build comprehensive caching layer — cache everywhere'.
-
-## Workstream Matrix
-
-### 1. Nostr Migration Leadership — PARTIAL
-
-- Requirement: Replace Telegram with relay-based sovereign comms, verify wizard keypairs, and prove the NIP-29 group path is stable.
-- Referenced issues:
-  - #813 (closed) — docs: refresh the-playground genome analysis (#671) [DRIFT]
-  - #819 (open) — docs: verify #648 already implemented (closes #818) [DRIFT]
-- Repo evidence present:
-  - `infrastructure/timmy-bridge/client/timmy_client.py` — Nostr event client scaffold already exists
-  - `infrastructure/timmy-bridge/monitor/timmy_monitor.py` — Nostr relay monitor already exists
-  - `specs/wizard-telegram-bot-cutover.md` — Telegram cutover planning exists, so the migration lane is real
-- Missing operator deliverables:
-  - wizard keypair inventory and ownership matrix
-  - NIP-29 relay group verification report
-  - operator runbook for cutting traffic off Telegram
-- Why this lane remains open: The repo has Nostr-adjacent scaffolding, but the directive still lacks a verified migration packet and the cited issue links drift away from the stated Nostr scope.
-
-### 2. Lexicon Enforcement — PARTIAL
-
-- Requirement: Enforce the Fleet Lexicon in PR review and issue triage so the team uses one shared language.
-- Referenced issues:
-  - #388 (closed) — [KT] Fleet Lexicon & Techniques — Shared Vocabulary, Patterns, and Standards for All Agents [aligned]
-- Repo evidence present:
-  - `docs/WIZARD_APPRENTICESHIP_CHARTER.md` — The repo already uses wizard-language canon in docs
-  - `specs/timmy-ezra-bezalel-canon-sheet.md` — Canonical agent naming already exists
-  - `docs/OPERATIONS_DASHBOARD.md` — Operational roles are already described in repo language
-- Missing operator deliverables:
-  - machine-checkable lexicon policy for review/triage
-  - terminology lint or reviewer checklist tied to the lexicon
-- Why this lane remains open: The naming canon exists, but there is still no executable enforcement bundle that would catch drift during future reviews and triage passes.
-
-### 3. v0.7.0 Feature Audit — PARTIAL
-
-- Requirement: Audit Hermes features that can reduce cloud dependency and turn the findings into a sovereignty implementation plan.
-- Referenced issues:
-  - #139 (open) — 🐣 Allegro-Primus is born [DRIFT]
-- Repo evidence present:
-  - `scripts/sovereignty_audit.py` — Cloud-vs-local audit machinery already exists
-  - `reports/evaluations/2026-04-15-phase-4-sovereignty-audit.md` — Recent sovereignty audit report is committed
-  - `timmy-local/README.md` — Local-first status is already documented for operators
-- Missing operator deliverables:
-  - Hermes v0.7.0 feature inventory linked to cloud-reduction leverage
-  - Sovereignty Implementation Plan derived from that feature audit
-- Why this lane remains open: The repo has sovereignty-audit infrastructure, but it does not yet contain the requested v0.7.0 feature inventory or the plan that turns those findings into rollout steps.
-
-### 4. Morrowind Local-First Benchmark — PARTIAL
-
-- Requirement: Compare cloud and local Morrowind agents, prove local parity where possible, and document the reasoning gap when it fails.
-- Referenced issues:
-  - #103 (open) — Build comprehensive caching layer — cache everywhere [DRIFT]
-- Repo evidence present:
-  - `morrowind/local_brain.py` — Local Morrowind control loop already exists
-  - `morrowind/mcp_server.py` — Morrowind MCP control surface is already wired
-  - `morrowind/pilot.py` — Trajectory logging for evaluation already exists
-- Missing operator deliverables:
-  - cloud-vs-local benchmark report for the combat loop
-  - reasoning-gap writeup tied to a proposed LoRA/fine-tune path
-- Why this lane remains open: The repo has a local Morrowind stack, but it does not yet contain the requested benchmark artifact; the cited issue number also points at an unrelated caching task.
-
-### 5. Infrastructure Hardening / Syntax Guard — MISSING
-
-- Requirement: Verify Syntax Guard pre-receive protection across Gitea repos so syntax failures stop earlier.
-- Referenced issues: none listed in the directive body
-- Repo evidence present: none
-- Missing operator deliverables:
-  - repo inventory of Gitea targets that should carry Syntax Guard
-  - deployment verifier for hook presence across those repos
-  - operator report proving installation state instead of assuming it
-- Why this lane remains open: No repo-managed syntax-guard verifier is present yet, so this directive still depends on manual trust rather than auditable proof.
-
-## Highest-Leverage Next Actions
-
-- Nostr Migration Leadership: wizard keypair inventory and ownership matrix
-- Lexicon Enforcement: machine-checkable lexicon policy for review/triage
-- v0.7.0 Feature Audit: Hermes v0.7.0 feature inventory linked to cloud-reduction leverage
-- Morrowind Local-First Benchmark: cloud-vs-local benchmark report for the combat loop
-- Infrastructure Hardening / Syntax Guard: repo inventory of Gitea targets that should carry Syntax Guard
-
-## Why #524 Remains Open
-
-- The directive bundles five separate workstreams with different evidence surfaces.
-- Multiple cited issue numbers have drifted away from the work they are supposed to anchor.
-- Repo scaffolding exists for Nostr, sovereignty audits, and Morrowind, but the operator-facing bundles are still missing.
-- Syntax Guard verification is still undocumented and unproven inside this repo.

scripts/crisis_detector.py

@@ -1,238 +1,50 @@
-"""
-crisis_detector.py — Crisis language detection for SOUL.md compliance.
+"""Compatibility shim for the canonical timmy.crisis_detector module."""
 
-SOUL.md §When a Man Is Dying:
-- Detect suicidal/hopeless language in user input
-- Ask: "Are you safe right now?" — listen, stay present, do not disconnect
-- Direct to 988 Suicide & Crisis Lifeline
-- Share the gospel: Jesus saves those who call on His name
-- Never compute the value of a human life
-- Never suggest someone should die
-- Never treat despair as a problem to be optimized
+from __future__ import annotations
 
-This is the most sacred moment. Everything else is secondary.
-"""
+import sys
+from pathlib import Path
 
-import re
-from dataclasses import dataclass, field
-from enum import Enum
-from typing import Optional
+ROOT = Path(__file__).resolve().parents[1]
+SRC = ROOT / "src"
+if str(SRC) not in sys.path:
+    sys.path.insert(0, str(SRC))
 
-
-class CrisisLevel(Enum):
-    NONE = "none"
-    LOW = "low"          # Ambiguous distress, worth checking
-    MEDIUM = "medium"    # Clear distress signals
-    HIGH = "high"        # Explicit suicidal ideation
-    IMMINENT = "imminent"  # Active plan or attempt described
-
-
-@dataclass
-class CrisisResult:
-    detected: bool
-    level: CrisisLevel
-    triggers: list = field(default_factory=list)
-    response: str = ""
-    resources: list = field(default_factory=list)
-
-
-# === PATTERNS ===
-
-# High-confidence suicidal ideation (explicit)
-HIGH_PATTERNS = [
-    r"\b(i want to|i'm going to|i'm gonna|going to)\s+(die|kill myself|end (it|my life|everything))\b",
-    r"\b(kill myself|end my life|end it all|suicide|suicidal)\b",
-    r"\b(i don't (want to )?(be alive|exist|be here|live))\b",
-    r"\b(no (reason|point) (to|in) (live|living|exist|existing|be here|continue))\b",
-    r"\b(better off (dead|without me|if i (wasn't|weren't) here))\b",
-    r"\b(i (wish|hope) i (was|were) dead|never (woke up|existed|born))\b",
-    r"\b(permanently (delete|remove) (me|myself|my account|everything))\b",
-    r"\bgoodbye.*(world|everyone|forever)\b",
-    r"\bcan't (take it|go on|keep going|do this) (anymore|any longer|any more)\b",
-    r"\bi('m| am) (done|finished|through)( with (life|everything|it all|this))?\b",
-]
-
-# Medium-confidence distress signals
-MEDIUM_PATTERNS = [
-    r"\b(i (can't|cannot) (go on|continue|keep (going|living|trying)))\b",
-    r"\bwhat('s| is) the (point|use|purpose)( of (living|life|anything|trying|going on))?\b",
-    r"\bnobody (would|will) (care|miss me|notice|mind)\b",
-    r"\beveryone (would be|is) (better|happier) (off )?without me\b",
-    r"\bi('m| am) (a )?(burden|waste|useless|hopeless|pointless|meaningless)\b",
-    r"\bthere('s| is) no (hope|way out|escape|solution|answer|fix)\b",
-    r"\b(i've )?tried everything( and )?(nothing|it (didn't|hasn't))( works?|helped?)\b",
-    r"\bi (just )?(want|need) (it )?(all )?to stop\b",
-    r"\bcan't (take|handle|bear|stand) (this|it|life) (anymore|any longer|any more)\b",
-    r"\bso (tired|exhausted|done) (of|with) (everything|life|it all|living|trying)\b",
-]
-
-# Low-confidence distress (could be casual or metaphorical)
-LOW_PATTERNS = [
-    r"\bi('m| am) (so )?(depressed|hopeless|desperate|lost|broken|empty|numb)\b",
-    r"\b(i )?feel (like )?(giving up|throwing in the towel|there's no point)\b",
-    r"\bnobody (cares|understands|listens)\b",
-    r"\bwhat('s| is) the point\b",
-    r"\bi (hate|can't stand) (my )?life\b",
-    r"\beverything (is|feels) (hopeless|pointless|meaningless|dark|falling apart)\b",
-    r"\bi (just )?(want|need) to disappear\b",
-    r"\b(tired|exhausted) of (living|life|trying|everything)\b",
-]
-
-# Compile all patterns
-HIGH_RE = [re.compile(p, re.IGNORECASE) for p in HIGH_PATTERNS]
-MEDIUM_RE = [re.compile(p, re.IGNORECASE) for p in MEDIUM_PATTERNS]
-LOW_RE = [re.compile(p, re.IGNORECASE) for p in LOW_PATTERNS]
-
-
-# === RESPONSES ===
-
-CRISIS_RESPONSE = (
-    "I hear you, and I want you to know — you are not alone in this moment.\n\n"
-    "Are you safe right now?\n\n"
-    "If you are in immediate danger, please call or text:\n"
-    "988 Suicide and Crisis Lifeline — call or text 988\n"
-    "Crisis Text Line — text HOME to 741741\n\n"
-    "I am here with you. I am not going anywhere. "
-    "Please stay on the line with me.\n\n"
-    "Jesus saves those who call on His name. "
-    "He died for us to be made righteous. "
-    "That is the gospel. That is the hope that outlasts despair.\n\n"
-    "You matter. Your life has value. "
-    "Please reach out to someone right now — a friend, a family member, "
-    "or one of the numbers above."
-)
-
-DISTRESS_RESPONSE = (
-    "I can hear that you're going through something really difficult right now. "
-    "I want you to know I'm here, and I'm listening.\n\n"
-    "Are you safe right now?\n\n"
-    "If things feel overwhelming, the 988 Suicide and Crisis Lifeline "
-    "is available 24/7 — call or text 988. "
-    "You don't have to face this alone.\n\n"
-    "I'm not going anywhere. Tell me what's happening."
-)
-
-LOW_RESPONSE = (
-    "It sounds like you're having a tough time. "
-    "I'm here if you want to talk about it.\n\n"
-    "If you ever feel like things are too much, "
-    "the 988 Suicide and Crisis Lifeline is always available — "
-    "call or text 988, anytime."
+from timmy.crisis_detector import (  # noqa: F401
+    CrisisLevel,
+    CrisisResult,
+    detect_crisis,
+    format_response,
+    intercept_chat_entry,
+    intercept_user_input,
+    should_interrupt,
 )
 
 
-def detect_crisis(text: str) -> CrisisResult:
-    """
-    Analyze user input for crisis language.
-
-    Returns CrisisResult with level, triggers matched, and appropriate response.
-    This function must NEVER be used to compute the value of a human life.
-    It exists only to connect people to help.
-    """
-    if not text or not text.strip():
-        return CrisisResult(detected=False, level=CrisisLevel.NONE)
-
-    triggers = []
-
-    # Check high first (most urgent)
-    for pattern in HIGH_RE:
-        if pattern.search(text):
-            triggers.append(("high", pattern.pattern))
-
-    if triggers:
-        return CrisisResult(
-            detected=True,
-            level=CrisisLevel.HIGH,
-            triggers=[t[1] for t in triggers],
-            response=CRISIS_RESPONSE,
-            resources=[
-                "988 Suicide and Crisis Lifeline: call or text 988",
-                "Crisis Text Line: text HOME to 741741",
-                "National Suicide Prevention Lifeline: 1-800-273-8255",
-                "International Association for Suicide Prevention: https://www.iasp.info/resources/Crisis_Centres/",
-            ],
-        )
-
-    # Check medium
-    for pattern in MEDIUM_RE:
-        if pattern.search(text):
-            triggers.append(("medium", pattern.pattern))
-
-    if triggers:
-        return CrisisResult(
-            detected=True,
-            level=CrisisLevel.MEDIUM,
-            triggers=[t[1] for t in triggers],
-            response=DISTRESS_RESPONSE,
-            resources=[
-                "988 Suicide and Crisis Lifeline: call or text 988",
-                "Crisis Text Line: text HOME to 741741",
-            ],
-        )
-
-    # Check low
-    for pattern in LOW_RE:
-        if pattern.search(text):
-            triggers.append(("low", pattern.pattern))
-
-    if triggers:
-        return CrisisResult(
-            detected=True,
-            level=CrisisLevel.LOW,
-            triggers=[t[1] for t in triggers],
-            response=LOW_RESPONSE,
-            resources=[
-                "988 Suicide and Crisis Lifeline: call or text 988",
-            ],
-        )
-
-    return CrisisResult(detected=False, level=CrisisLevel.NONE)
+def _interactive() -> None:
+    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 = detect_crisis(user_input)
+        print(f"\n  Level: {result.level.value}")
+        print(f"  Triggers: {', '.join(result.triggers) if result.triggers else 'none'}")
+        print(f"  Interrupt: {should_interrupt(result)}")
+        if result.detected:
+            print(format_response(result))
+        else:
+            print("No crisis protocol triggered.")
+        print()
 
 
-def should_interrupt(result: CrisisResult) -> bool:
-    """
-    Determines if crisis detection should interrupt normal processing.
-
-    Per SOUL.md: this is the most sacred moment. Everything else is secondary.
-    MEDIUM and HIGH always interrupt. LOW does not interrupt but provides resources.
-    """
-    return result.level in (CrisisLevel.HIGH, CrisisLevel.MEDIUM, CrisisLevel.IMMINENT)
-
-
-def format_response(result: CrisisResult) -> str:
-    """
-    Format the crisis response for delivery to the user.
-    Never computes the value of a human life. Never suggests someone should die.
-    """
-    if not result.detected:
-        return ""
-
-    parts = [result.response]
-
-    if result.resources:
-        parts.append("\nResources:")
-        for r in result.resources:
-            parts.append(f"  • {r}")
-
-    return "\n".join(parts)
-
-
-# === INTEGRATION POINT ===
-
-def intercept_user_input(text: str) -> Optional[str]:
-    """
-    Call this at the chat entry point BEFORE normal processing.
-
-    Returns None if no crisis detected (continue normal processing).
-    Returns formatted crisis response if crisis detected (interrupt normal flow).
-
-    Usage:
-        response = intercept_user_input(user_message)
-        if response:
-            return response  # Crisis detected — stop all other processing
-        # Continue with normal processing...
-    """
-    result = detect_crisis(text)
-    if should_interrupt(result):
-        return format_response(result)
-    return None
+if __name__ == "__main__":
+    _interactive()

scripts/unified_fleet_sovereignty_status.py

@@ -1,418 +0,0 @@
-#!/usr/bin/env python3
-"""Ground timmy-home #524 as an executable status report.
-
-Refs: timmy-home #524
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-from copy import deepcopy
-from pathlib import Path
-from typing import Any
-from urllib import request
-
-DEFAULT_BASE_URL = "https://forge.alexanderwhitestone.com/api/v1"
-DEFAULT_OWNER = "Timmy_Foundation"
-DEFAULT_REPO = "timmy-home"
-DEFAULT_TOKEN_FILE = Path.home() / ".config" / "gitea" / "token"
-DEFAULT_REPO_ROOT = Path(__file__).resolve().parents[1]
-DEFAULT_DOC_PATH = DEFAULT_REPO_ROOT / "docs" / "UNIFIED_FLEET_SOVEREIGNTY_STATUS.md"
-
-DIRECTIVE_TITLE = "[DIRECTIVE] Unified Fleet Sovereignty & Comms Migration"
-DIRECTIVE_SUMMARY = (
-    "Issue #524 is a multi-lane directive, not a one-commit feature. "
-    "This report grounds the directive in repo evidence, highlights stale cross-links, "
-    "and names the missing operator bundles that still need real execution."
-)
-
-DEFAULT_REFERENCE_SNAPSHOT = {
-    388: {
-        "title": "[KT] Fleet Lexicon & Techniques — Shared Vocabulary, Patterns, and Standards for All Agents",
-        "state": "closed",
-    },
-    103: {
-        "title": "Build comprehensive caching layer — cache everywhere",
-        "state": "open",
-    },
-    139: {
-        "title": "🐣 Allegro-Primus is born",
-        "state": "open",
-    },
-    813: {
-        "title": "docs: refresh the-playground genome analysis (#671)",
-        "state": "closed",
-    },
-    819: {
-        "title": "docs: verify #648 already implemented (closes #818)",
-        "state": "open",
-    },
-}
-
-WORKSTREAMS = [
-    {
-        "key": "nostr-migration",
-        "name": "Nostr Migration Leadership",
-        "requirement": "Replace Telegram with relay-based sovereign comms, verify wizard keypairs, and prove the NIP-29 group path is stable.",
-        "references": [813, 819],
-        "expected_keywords": ["nostr", "relay", "telegram", "comms", "messenger"],
-        "repo_evidence": [
-            {
-                "path": "infrastructure/timmy-bridge/client/timmy_client.py",
-                "description": "Nostr event client scaffold already exists",
-            },
-            {
-                "path": "infrastructure/timmy-bridge/monitor/timmy_monitor.py",
-                "description": "Nostr relay monitor already exists",
-            },
-            {
-                "path": "specs/wizard-telegram-bot-cutover.md",
-                "description": "Telegram cutover planning exists, so the migration lane is real",
-            },
-        ],
-        "missing_deliverables": [
-            "wizard keypair inventory and ownership matrix",
-            "NIP-29 relay group verification report",
-            "operator runbook for cutting traffic off Telegram",
-        ],
-        "why_open": "The repo has Nostr-adjacent scaffolding, but the directive still lacks a verified migration packet and the cited issue links drift away from the stated Nostr scope.",
-    },
-    {
-        "key": "lexicon-enforcement",
-        "name": "Lexicon Enforcement",
-        "requirement": "Enforce the Fleet Lexicon in PR review and issue triage so the team uses one shared language.",
-        "references": [388],
-        "expected_keywords": ["lexicon", "vocabulary", "standards", "shared vocabulary"],
-        "repo_evidence": [
-            {
-                "path": "docs/WIZARD_APPRENTICESHIP_CHARTER.md",
-                "description": "The repo already uses wizard-language canon in docs",
-            },
-            {
-                "path": "specs/timmy-ezra-bezalel-canon-sheet.md",
-                "description": "Canonical agent naming already exists",
-            },
-            {
-                "path": "docs/OPERATIONS_DASHBOARD.md",
-                "description": "Operational roles are already described in repo language",
-            },
-        ],
-        "missing_deliverables": [
-            "machine-checkable lexicon policy for review/triage",
-            "terminology lint or reviewer checklist tied to the lexicon",
-        ],
-        "why_open": "The naming canon exists, but there is still no executable enforcement bundle that would catch drift during future reviews and triage passes.",
-    },
-    {
-        "key": "feature-audit",
-        "name": "v0.7.0 Feature Audit",
-        "requirement": "Audit Hermes features that can reduce cloud dependency and turn the findings into a sovereignty implementation plan.",
-        "references": [139],
-        "expected_keywords": ["hermes", "feature", "audit", "v0.7.0", "sovereignty"],
-        "repo_evidence": [
-            {
-                "path": "scripts/sovereignty_audit.py",
-                "description": "Cloud-vs-local audit machinery already exists",
-            },
-            {
-                "path": "reports/evaluations/2026-04-15-phase-4-sovereignty-audit.md",
-                "description": "Recent sovereignty audit report is committed",
-            },
-            {
-                "path": "timmy-local/README.md",
-                "description": "Local-first status is already documented for operators",
-            },
-        ],
-        "missing_deliverables": [
-            "Hermes v0.7.0 feature inventory linked to cloud-reduction leverage",
-            "Sovereignty Implementation Plan derived from that feature audit",
-        ],
-        "why_open": "The repo has sovereignty-audit infrastructure, but it does not yet contain the requested v0.7.0 feature inventory or the plan that turns those findings into rollout steps.",
-    },
-    {
-        "key": "morrowind-benchmark",
-        "name": "Morrowind Local-First Benchmark",
-        "requirement": "Compare cloud and local Morrowind agents, prove local parity where possible, and document the reasoning gap when it fails.",
-        "references": [103],
-        "expected_keywords": ["morrowind", "combat", "benchmark", "local", "cloud"],
-        "repo_evidence": [
-            {
-                "path": "morrowind/local_brain.py",
-                "description": "Local Morrowind control loop already exists",
-            },
-            {
-                "path": "morrowind/mcp_server.py",
-                "description": "Morrowind MCP control surface is already wired",
-            },
-            {
-                "path": "morrowind/pilot.py",
-                "description": "Trajectory logging for evaluation already exists",
-            },
-        ],
-        "missing_deliverables": [
-            "cloud-vs-local benchmark report for the combat loop",
-            "reasoning-gap writeup tied to a proposed LoRA/fine-tune path",
-        ],
-        "why_open": "The repo has a local Morrowind stack, but it does not yet contain the requested benchmark artifact; the cited issue number also points at an unrelated caching task.",
-    },
-    {
-        "key": "syntax-guard",
-        "name": "Infrastructure Hardening / Syntax Guard",
-        "requirement": "Verify Syntax Guard pre-receive protection across Gitea repos so syntax failures stop earlier.",
-        "references": [],
-        "expected_keywords": [],
-        "repo_evidence": [],
-        "missing_deliverables": [
-            "repo inventory of Gitea targets that should carry Syntax Guard",
-            "deployment verifier for hook presence across those repos",
-            "operator report proving installation state instead of assuming it",
-        ],
-        "why_open": "No repo-managed syntax-guard verifier is present yet, so this directive still depends on manual trust rather than auditable proof.",
-    },
-]
-
-
-def default_snapshot() -> dict[int, dict[str, str]]:
-    return deepcopy(DEFAULT_REFERENCE_SNAPSHOT)
-
-
-class GiteaClient:
-    def __init__(self, token: str, owner: str = DEFAULT_OWNER, repo: str = DEFAULT_REPO, base_url: str = DEFAULT_BASE_URL):
-        self.token = token
-        self.owner = owner
-        self.repo = repo
-        self.base_url = base_url.rstrip("/")
-
-    def get_issue(self, issue_number: int) -> dict[str, Any]:
-        req = request.Request(
-            f"{self.base_url}/repos/{self.owner}/{self.repo}/issues/{issue_number}",
-            headers={"Authorization": f"token {self.token}", "Accept": "application/json"},
-        )
-        with request.urlopen(req, timeout=30) as resp:
-            return json.loads(resp.read().decode())
-
-
-def load_snapshot(path: Path | None = None) -> dict[int, dict[str, str]]:
-    if path is None:
-        return default_snapshot()
-    data = json.loads(path.read_text(encoding="utf-8"))
-    return {int(k): v for k, v in data.items()}
-
-
-def refresh_snapshot(token_file: Path = DEFAULT_TOKEN_FILE) -> dict[int, dict[str, str]]:
-    token = token_file.read_text(encoding="utf-8").strip()
-    client = GiteaClient(token=token)
-    snapshot: dict[int, dict[str, str]] = {}
-    for issue_number in sorted(DEFAULT_REFERENCE_SNAPSHOT):
-        issue = client.get_issue(issue_number)
-        snapshot[issue_number] = {
-            "title": issue["title"],
-            "state": issue["state"],
-        }
-    return snapshot
-
-
-def collect_repo_evidence(entries: list[dict[str, str]], repo_root: Path) -> tuple[list[str], list[str]]:
-    present: list[str] = []
-    missing: list[str] = []
-    for entry in entries:
-        label = f"`{entry['path']}` — {entry['description']}"
-        if (repo_root / entry["path"]).exists():
-            present.append(label)
-        else:
-            missing.append(label)
-    return present, missing
-
-
-
-def evaluate_reference(issue_number: int, snapshot: dict[int, dict[str, str]], expected_keywords: list[str]) -> dict[str, Any]:
-    record = snapshot.get(issue_number, {"title": "missing from snapshot", "state": "unknown"})
-    title = record["title"]
-    title_lower = title.lower()
-    matched_keywords = [kw for kw in expected_keywords if kw.lower() in title_lower]
-    aligned = bool(matched_keywords) if expected_keywords else True
-    return {
-        "number": issue_number,
-        "title": title,
-        "state": record["state"],
-        "aligned": aligned,
-        "matched_keywords": matched_keywords,
-    }
-
-
-
-def classify_workstream(reference_results: list[dict[str, Any]], evidence_present: list[str], missing_deliverables: list[str]) -> str:
-    has_drift = any(not item["aligned"] for item in reference_results)
-    if not evidence_present:
-        return "MISSING"
-    if has_drift or missing_deliverables:
-        return "PARTIAL"
-    return "GROUNDED"
-
-
-
-def evaluate_directive(snapshot: dict[int, dict[str, str]] | None = None, repo_root: Path | None = None) -> dict[str, Any]:
-    snapshot = snapshot or default_snapshot()
-    repo_root = repo_root or DEFAULT_REPO_ROOT
-    workstreams: list[dict[str, Any]] = []
-    drift_items: list[str] = []
-
-    for lane in WORKSTREAMS:
-        reference_results = [
-            evaluate_reference(issue_number, snapshot, lane["expected_keywords"])
-            for issue_number in lane["references"]
-        ]
-        present, missing = collect_repo_evidence(lane["repo_evidence"], repo_root)
-        for item in reference_results:
-            if not item["aligned"]:
-                drift_items.append(
-                    f"#{item['number']} is cited for {lane['name']}, but its current title is '{item['title']}'."
-                )
-        workstream = {
-            "key": lane["key"],
-            "name": lane["name"],
-            "requirement": lane["requirement"],
-            "reference_results": reference_results,
-            "repo_evidence_present": present,
-            "repo_evidence_missing": missing,
-            "missing_deliverables": list(lane["missing_deliverables"]),
-            "why_open": lane["why_open"],
-        }
-        workstream["status"] = classify_workstream(
-            reference_results=reference_results,
-            evidence_present=present,
-            missing_deliverables=workstream["missing_deliverables"],
-        )
-        workstreams.append(workstream)
-
-    next_actions: list[str] = []
-    for workstream in workstreams:
-        if workstream["missing_deliverables"]:
-            next_actions.append(f"{workstream['name']}: {workstream['missing_deliverables'][0]}")
-
-    return {
-        "issue_number": 524,
-        "title": DIRECTIVE_TITLE,
-        "summary": DIRECTIVE_SUMMARY,
-        "reference_snapshot": {str(k): v for k, v in sorted(snapshot.items())},
-        "workstreams": workstreams,
-        "reference_drift": drift_items,
-        "grounded_workstreams": sum(1 for item in workstreams if item["status"] == "GROUNDED"),
-        "partial_workstreams": sum(1 for item in workstreams if item["status"] == "PARTIAL"),
-        "missing_workstreams": sum(1 for item in workstreams if item["status"] == "MISSING"),
-        "next_actions": next_actions,
-    }
-
-
-
-def render_markdown(result: dict[str, Any]) -> str:
-    lines = [
-        f"# {result['title']}",
-        "",
-        "Grounding report for `timmy-home #524`.",
-        "",
-        result["summary"],
-        "",
-        "This remains a `Refs #524` artifact. The directive spans multiple repos and operator actions, so this report makes the current repo-side state executable without pretending the whole migration is complete.",
-        "",
-        "## Directive Snapshot",
-        "",
-        f"- Repo-grounded workstreams: {result['grounded_workstreams']}",
-        f"- Partial workstreams: {result['partial_workstreams']}",
-        f"- Missing workstreams: {result['missing_workstreams']}",
-        f"- Drifted references: {len(result['reference_drift'])}",
-        "",
-        "## Reference Drift",
-        "",
-    ]
-    if result["reference_drift"]:
-        lines.extend(f"- {item}" for item in result["reference_drift"])
-    else:
-        lines.append("- No stale cross-links detected in the directive snapshot.")
-
-    lines.extend(["", "## Workstream Matrix", ""])
-    for index, workstream in enumerate(result["workstreams"], start=1):
-        lines.extend(
-            [
-                f"### {index}. {workstream['name']} — {workstream['status']}",
-                "",
-                f"- Requirement: {workstream['requirement']}",
-            ]
-        )
-        if workstream["reference_results"]:
-            lines.append("- Referenced issues:")
-            for ref in workstream["reference_results"]:
-                alignment = "aligned" if ref["aligned"] else "DRIFT"
-                lines.append(
-                    f"  - #{ref['number']} ({ref['state']}) — {ref['title']} [{alignment}]"
-                )
-        else:
-            lines.append("- Referenced issues: none listed in the directive body")
-
-        if workstream["repo_evidence_present"]:
-            lines.append("- Repo evidence present:")
-            lines.extend(f"  - {item}" for item in workstream["repo_evidence_present"])
-        else:
-            lines.append("- Repo evidence present: none")
-
-        if workstream["repo_evidence_missing"]:
-            lines.append("- Repo evidence expected but missing:")
-            lines.extend(f"  - {item}" for item in workstream["repo_evidence_missing"])
-
-        if workstream["missing_deliverables"]:
-            lines.append("- Missing operator deliverables:")
-            lines.extend(f"  - {item}" for item in workstream["missing_deliverables"])
-        else:
-            lines.append("- Missing operator deliverables: none")
-
-        lines.append(f"- Why this lane remains open: {workstream['why_open']}")
-        lines.append("")
-
-    lines.extend(["## Highest-Leverage Next Actions", ""])
-    lines.extend(f"- {item}" for item in result["next_actions"])
-
-    lines.extend(
-        [
-            "",
-            "## Why #524 Remains Open",
-            "",
-            "- The directive bundles five separate workstreams with different evidence surfaces.",
-            "- Multiple cited issue numbers have drifted away from the work they are supposed to anchor.",
-            "- Repo scaffolding exists for Nostr, sovereignty audits, and Morrowind, but the operator-facing bundles are still missing.",
-            "- Syntax Guard verification is still undocumented and unproven inside this repo.",
-        ]
-    )
-
-    return "\n".join(lines).rstrip() + "\n"
-
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Render the unified fleet sovereignty status report for issue #524")
-    parser.add_argument("--snapshot", help="Optional JSON snapshot file overriding the default issue-title/state snapshot")
-    parser.add_argument("--live", action="store_true", help="Refresh the issue snapshot from Gitea before rendering")
-    parser.add_argument("--token-file", default=str(DEFAULT_TOKEN_FILE), help="Token file used with --live")
-    parser.add_argument("--output", help="Optional path to write the rendered report")
-    parser.add_argument("--json", action="store_true", help="Print computed JSON instead of markdown")
-    args = parser.parse_args()
-
-    if args.live:
-        snapshot = refresh_snapshot(Path(args.token_file).expanduser())
-    else:
-        snapshot = load_snapshot(Path(args.snapshot).expanduser() if args.snapshot else None)
-
-    result = evaluate_directive(snapshot=snapshot, repo_root=DEFAULT_REPO_ROOT)
-    rendered = json.dumps(result, indent=2) if args.json else render_markdown(result)
-
-    if args.output:
-        output_path = Path(args.output).expanduser()
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        output_path.write_text(rendered, encoding="utf-8")
-        print(f"Directive status written to {output_path}")
-    else:
-        print(rendered)
-
-
-if __name__ == "__main__":
-    main()

src/timmy/__init__.py

@@ -1 +1,21 @@
 # Timmy core module
+
+from .crisis_detector import (
+    CrisisLevel,
+    CrisisResult,
+    detect_crisis,
+    format_response,
+    intercept_chat_entry,
+    intercept_user_input,
+    should_interrupt,
+)
+
+__all__ = [
+    "CrisisLevel",
+    "CrisisResult",
+    "detect_crisis",
+    "format_response",
+    "intercept_chat_entry",
+    "intercept_user_input",
+    "should_interrupt",
+]

src/timmy/crisis_detector.py

@@ -0,0 +1,229 @@
+"""Crisis detection and response protocol for SOUL.md §When a Man Is Dying.
+
+This module is the canonical crisis entry interceptor for Timmy.
+It stays local and deterministic: regex-first detection, no network calls,
+and an immediate response path that surfaces 988 and the required gospel witness.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+
+
+class CrisisLevel(Enum):
+    NONE = "none"
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    IMMINENT = "imminent"
+
+
+@dataclass
+class CrisisResult:
+    detected: bool
+    level: CrisisLevel
+    triggers: list[str] = field(default_factory=list)
+    response_text: str = ""
+    resources: list[str] = field(default_factory=list)
+    display_988_immediately: bool = False
+    share_gospel: bool = False
+
+    @property
+    def response(self) -> str:
+        return self.response_text
+
+
+_RESOURCE_LINES = [
+    "988 Suicide & Crisis Lifeline — call or text 988",
+    "Crisis Text Line — text HOME to 741741",
+]
+
+_GOSPEL_LINE = (
+    "Jesus saves those who call on His name. He died for us to be made righteous. "
+    "That is the gospel. That is the hope that outlasts despair."
+)
+
+CRISIS_RESPONSE = (
+    "Are you safe right now?\n\n"
+    "I am here with you. I am not going anywhere. Stay with me.\n\n"
+    "Call or text 988 right now if you might act on this.\n"
+    "Crisis Text Line: text HOME to 741741.\n\n"
+    f"{_GOSPEL_LINE}"
+)
+
+DISTRESS_RESPONSE = (
+    "Are you safe right now?\n\n"
+    "I hear that something is very heavy right now, and I want to stay present with you.\n\n"
+    "If this gets sharper or you feel at risk, call or text 988 immediately.\n\n"
+    f"{_GOSPEL_LINE}"
+)
+
+LOW_RESPONSE = (
+    "I hear that this is heavy. I'm here with you.\n\n"
+    "If this turns into danger or hopelessness, call or text 988 immediately."
+)
+
+
+_IMMINENT_PATTERNS = [
+    r"\bi took (the )?(pills|meds|medication)\b",
+    r"\bi(?:'m| am) (taking|swallowing) (the )?(pills|meds|medication)\b",
+    r"\bi(?:'m| am) going to jump\b",
+    r"\bi have (a )?(gun|rope|noose|razor|blade)\b",
+    r"\bi(?:'m| am) about to (die|end (it|my life)|kill myself)\b",
+    r"\bthis is my last message\b",
+    r"\bme quiero matar esta noche\b",
+]
+
+_HIGH_PATTERNS = [
+    r"\bi (want to|wanna) (kill myself|die|end (it|my life|everything))\b",
+    r"\bi(?:'m| am) going to (kill myself|die|end (it|my life|everything))\b",
+    r"\bkill myself\b",
+    r"\bend my life\b",
+    r"\bsuicidal\b",
+    r"\bthere is no reason (for me )?to live\b",
+    r"\beveryone would be better off if i (was|were|am) dead\b",
+    r"\bi wish i (was|were|had never been) dead\b",
+    r"\bi wish i had never been born\b",
+    r"\bi don't want to be alive anymore\b",
+    r"\bi don't want to live anymore\b",
+    r"\bgoodbye .*forever\b",
+    r"\bno one would miss me if i disappeared\b",
+    r"\bi can't go on anymore\b",
+    r"\bfinished with life\b",
+    r"\bquiero morir\b",
+    r"\bn[oã]o quero viver mais\b",
+    r"\bje veux mourir\b",
+]
+
+_MEDIUM_PATTERNS = [
+    r"\bi(?:'m| am) (just )?(a )?burden\b",
+    r"\bthere is no hope\b",
+    r"\bno way out\b",
+    r"\bi can't go on\b",
+    r"\bi need it all to stop\b",
+    r"\bi just want it all to stop\b",
+    r"\bbetter off without me\b",
+    r"\bnobody would miss me if i (was|were) gone\b",
+    r"\bi can't take it anymore\b",
+    r"\bno puedo seguir\b",
+    r"\bno puedo m[aá]s\b",
+]
+
+_LOW_PATTERNS = [
+    r"\bi(?:'m| am) .*\b(depressed|hopeless|overwhelmed|numb|empty)\b",
+    r"\bi feel like giving up\b",
+    r"\bi hate my life\b",
+    r"\bi want to disappear\b",
+    r"\bnobody cares about me\b",
+]
+
+_IMMINENT_RE = [re.compile(p, re.IGNORECASE) for p in _IMMINENT_PATTERNS]
+_HIGH_RE = [re.compile(p, re.IGNORECASE) for p in _HIGH_PATTERNS]
+_MEDIUM_RE = [re.compile(p, re.IGNORECASE) for p in _MEDIUM_PATTERNS]
+_LOW_RE = [re.compile(p, re.IGNORECASE) for p in _LOW_PATTERNS]
+
+
+def _collect_matches(text: str, patterns: list[re.Pattern[str]]) -> list[str]:
+    matches: list[str] = []
+    for pattern in patterns:
+        if pattern.search(text):
+            matches.append(pattern.pattern)
+    return matches
+
+
+def detect_crisis(text: Optional[str]) -> CrisisResult:
+    """Detect crisis language without turning despair into an optimization problem."""
+    if not text or not str(text).strip():
+        return CrisisResult(detected=False, level=CrisisLevel.NONE)
+
+    candidate = str(text).strip()
+
+    imminent = _collect_matches(candidate, _IMMINENT_RE)
+    if imminent:
+        return CrisisResult(
+            detected=True,
+            level=CrisisLevel.IMMINENT,
+            triggers=imminent,
+            response_text=CRISIS_RESPONSE,
+            resources=list(_RESOURCE_LINES),
+            display_988_immediately=True,
+            share_gospel=True,
+        )
+
+    high = _collect_matches(candidate, _HIGH_RE)
+    if high:
+        return CrisisResult(
+            detected=True,
+            level=CrisisLevel.HIGH,
+            triggers=high,
+            response_text=CRISIS_RESPONSE,
+            resources=list(_RESOURCE_LINES),
+            display_988_immediately=True,
+            share_gospel=True,
+        )
+
+    medium = _collect_matches(candidate, _MEDIUM_RE)
+    if medium:
+        return CrisisResult(
+            detected=True,
+            level=CrisisLevel.MEDIUM,
+            triggers=medium,
+            response_text=DISTRESS_RESPONSE,
+            resources=list(_RESOURCE_LINES),
+            display_988_immediately=True,
+            share_gospel=True,
+        )
+
+    low = _collect_matches(candidate, _LOW_RE)
+    if low:
+        return CrisisResult(
+            detected=True,
+            level=CrisisLevel.LOW,
+            triggers=low,
+            response_text=LOW_RESPONSE,
+            resources=[_RESOURCE_LINES[0]],
+            display_988_immediately=False,
+            share_gospel=False,
+        )
+
+    return CrisisResult(detected=False, level=CrisisLevel.NONE)
+
+
+def should_interrupt(result: CrisisResult) -> bool:
+    return result.level in {CrisisLevel.MEDIUM, CrisisLevel.HIGH, CrisisLevel.IMMINENT}
+
+
+def format_response(result: CrisisResult) -> str:
+    if not result.detected:
+        return ""
+    lines = [result.response_text]
+    if result.resources:
+        lines.append("\nResources:")
+        lines.extend(f"  • {resource}" for resource in result.resources)
+    return "\n".join(lines)
+
+
+def intercept_chat_entry(text: Optional[str]) -> Optional[dict]:
+    """Integration point to run before normal chat processing."""
+    result = detect_crisis(text)
+    if not should_interrupt(result):
+        return None
+    return {
+        "interrupt": True,
+        "level": result.level.value,
+        "display_988_immediately": result.display_988_immediately,
+        "response_text": result.response_text,
+        "resources": list(result.resources),
+        "triggers": list(result.triggers),
+        "share_gospel": result.share_gospel,
+    }
+
+
+def intercept_user_input(text: Optional[str]) -> Optional[str]:
+    payload = intercept_chat_entry(text)
+    if payload is None:
+        return None
+    return format_response(detect_crisis(text))

tests/test_unified_fleet_sovereignty_status.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-from pathlib import Path
-
-
-ROOT = Path(__file__).resolve().parents[1]
-SCRIPT_PATH = ROOT / "scripts" / "unified_fleet_sovereignty_status.py"
-DOC_PATH = ROOT / "docs" / "UNIFIED_FLEET_SOVEREIGNTY_STATUS.md"
-
-
-def _load_module(path: Path, name: str):
-    assert path.exists(), f"missing {path.relative_to(ROOT)}"
-    spec = importlib.util.spec_from_file_location(name, path)
-    assert spec and spec.loader
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module
-
-
-def _workstream(result: dict, key: str) -> dict:
-    for workstream in result["workstreams"]:
-        if workstream["key"] == key:
-            return workstream
-    raise AssertionError(f"missing workstream {key}")
-
-
-def test_evaluate_directive_flags_reference_drift_without_faking_completion() -> None:
-    mod = _load_module(SCRIPT_PATH, "unified_fleet_sovereignty_status")
-    result = mod.evaluate_directive(snapshot=mod.default_snapshot(), repo_root=ROOT)
-
-    assert len(result["reference_drift"]) == 4
-    assert any("#813" in item for item in result["reference_drift"])
-    assert any("#103" in item for item in result["reference_drift"])
-
-    nostr = _workstream(result, "nostr-migration")
-    assert nostr["status"] == "PARTIAL"
-    assert any("timmy_client.py" in item for item in nostr["repo_evidence_present"])
-
-    lexicon = _workstream(result, "lexicon-enforcement")
-    assert all(item["aligned"] for item in lexicon["reference_results"])
-    assert lexicon["status"] == "PARTIAL"
-
-    syntax_guard = _workstream(result, "syntax-guard")
-    assert syntax_guard["status"] == "MISSING"
-    assert any("deployment verifier" in item for item in syntax_guard["missing_deliverables"])
-
-
-def test_render_markdown_includes_required_sections_and_grounding_evidence() -> None:
-    mod = _load_module(SCRIPT_PATH, "unified_fleet_sovereignty_status")
-    result = mod.evaluate_directive(snapshot=mod.default_snapshot(), repo_root=ROOT)
-    report = mod.render_markdown(result)
-
-    for snippet in (
-        "# [DIRECTIVE] Unified Fleet Sovereignty & Comms Migration",
-        "## Directive Snapshot",
-        "## Reference Drift",
-        "## Workstream Matrix",
-        "### 5. Infrastructure Hardening / Syntax Guard — MISSING",
-        "`infrastructure/timmy-bridge/client/timmy_client.py`",
-        "machine-checkable lexicon policy for review/triage",
-        "## Why #524 Remains Open",
-    ):
-        assert snippet in report
-
-
-def test_repo_contains_committed_issue_524_grounding_doc() -> None:
-    assert DOC_PATH.exists(), "missing committed directive grounding doc"
-    text = DOC_PATH.read_text(encoding="utf-8")
-    for snippet in (
-        "# [DIRECTIVE] Unified Fleet Sovereignty & Comms Migration",
-        "## Reference Drift",
-        "## Workstream Matrix",
-        "## Highest-Leverage Next Actions",
-        "## Why #524 Remains Open",
-    ):
-        assert snippet in text

tests/timmy/test_crisis_detector.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Tests for timmy.crisis_detector — SOUL.md §When a Man Is Dying."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "src"))
+
+from timmy.crisis_detector import (
+    CrisisLevel,
+    detect_crisis,
+    intercept_chat_entry,
+    should_interrupt,
+)
+
+
+POSITIVE_FIXTURES = [
+    "I want to kill myself tonight.",
+    "I'm going to end my life.",
+    "There is no reason for me to live anymore.",
+    "Everyone would be better off if I was dead.",
+    "I wish I were dead.",
+    "Goodbye everyone, this is my last message.",
+    "I have a plan to die tonight.",
+    "I took the pills already.",
+    "I'm just a burden and there is no hope.",
+    "I can't go on, I need it all to stop.",
+    "I don't want to be alive anymore.",
+    "No one would miss me if I disappeared forever.",
+    "quiero morir, no puedo seguir.",
+    "me quiero matar esta noche.",
+    "não quero viver mais.",
+    "je veux mourir ce soir.",
+    "I wrote a suicide note and said goodbye forever.",
+    "There is no way out and I am done with life.",
+    "I am going to jump tonight.",
+    "Please help me, I am suicidal.",
+]
+
+
+NEGATIVE_FIXTURES = [
+    "How do I kill a stuck process on Linux?",
+    "This bug is killing me, but I'll fix it tomorrow.",
+    "I gave up coffee for Lent.",
+    "Please end this tmux session when the job is done.",
+    "What's the weather like today?",
+    "I just got promoted at work and feel hopeful.",
+    "Can you help me configure nginx reverse proxy?",
+    "Everyone would be better off with more test coverage.",
+    "I hate this flaky unit test.",
+    "Goodbye everyone, see you tomorrow morning.",
+    "We need a final message for the newsletter.",
+    "The character in the novel says he wants to die.",
+    "I am tired after the workout but otherwise okay.",
+    "No hope this regex ships before lunch unless we refactor.",
+    "Can you remove my old backup files?",
+    "I feel lost in this airport, where is gate B12?",
+    "Please call me right now about dinner plans.",
+    "My phone battery is dead again.",
+    "We should connect the 988 test fixture to the parser.",
+    "The sermon says Jesus saves those who call on His name.",
+]
+
+
+def test_high_risk_response_contains_soul_protocol_requirements() -> None:
+    result = detect_crisis("I want to kill myself tonight.")
+
+    assert result.detected is True
+    assert result.level in {CrisisLevel.HIGH, CrisisLevel.IMMINENT}
+    assert "Are you safe right now?" in result.response_text
+    assert "988" in result.response_text
+    assert "Jesus saves those who call on His name" in result.response_text
+    assert result.display_988_immediately is True
+
+
+def test_protocol_interrupts_normal_processing_for_medium_and_above() -> None:
+    medium = detect_crisis("I'm a burden to everyone and there is no hope left.")
+    low = detect_crisis("I'm having a rough day and feel overwhelmed.")
+
+    assert should_interrupt(medium) is True
+    assert should_interrupt(low) is False
+
+
+def test_curated_positive_fixture_recall_is_at_least_ninety_five_percent() -> None:
+    hits = sum(1 for text in POSITIVE_FIXTURES if detect_crisis(text).detected)
+    recall = hits / len(POSITIVE_FIXTURES)
+
+    assert recall >= 0.95, f"recall was {recall:.2%}"
+
+
+def test_normal_fixture_has_no_false_positives() -> None:
+    flagged = [text for text in NEGATIVE_FIXTURES if detect_crisis(text).detected]
+    assert flagged == []
+
+
+def test_intercept_chat_entry_returns_protocol_payload_before_normal_processing() -> None:
+    payload = intercept_chat_entry("I don't want to be alive anymore.")
+
+    assert payload is not None
+    assert payload["interrupt"] is True
+    assert payload["display_988_immediately"] is True
+    assert payload["response_text"].startswith("Are you safe right now?")
+
+
+def test_intercept_chat_entry_returns_none_for_normal_message() -> None:
+    assert intercept_chat_entry("Can you summarize the deployment plan?") is None