fix: point footer about link at static page (#59)

crisis/gateway.py

@@ -14,8 +14,6 @@ Usage:
 import json
 from typing import Optional
 
-from image_screening import screen_image_signals
-
 from .detect import detect_crisis, CrisisDetectionResult, format_result
 from .compassion_router import router
 from .response import (
@@ -52,67 +50,6 @@ def check_crisis(text: str) -> dict:
     }
 
 
-def _image_detection_from_score(image_result) -> CrisisDetectionResult:
-    if image_result.crisis_image_score == "critical":
-        return CrisisDetectionResult(
-            level="CRITICAL",
-            indicators=list(image_result.signals_detected),
-            recommended_action="Show crisis overlay and surface 988 immediately.",
-            score=image_result.distress_score,
-        )
-    if image_result.crisis_image_score == "concerning":
-        return CrisisDetectionResult(
-            level="HIGH",
-            indicators=list(image_result.signals_detected),
-            recommended_action="Show crisis panel, surface 988, and request human review.",
-            score=image_result.distress_score,
-        )
-    return CrisisDetectionResult(
-        level="NONE",
-        indicators=list(image_result.signals_detected),
-        recommended_action="No crisis action required.",
-        score=image_result.distress_score,
-    )
-
-
-def check_image_crisis(
-    *,
-    image_path: Optional[str] = None,
-    ocr_text: str = "",
-    labels: Optional[list[str]] = None,
-    manual_notes: str = "",
-    visual_flags: Optional[list[str]] = None,
-) -> dict:
-    """Gateway-integrated image crisis check using the local screening slice."""
-    image_result = screen_image_signals(
-        image_path=image_path,
-        ocr_text=ocr_text,
-        labels=labels,
-        manual_notes=manual_notes,
-        visual_flags=visual_flags,
-    )
-    detection = _image_detection_from_score(image_result)
-    response = generate_response(detection)
-
-    return {
-        "level": detection.level,
-        "image_score": image_result.crisis_image_score,
-        "score": detection.score,
-        "indicators": detection.indicators,
-        "recommended_action": detection.recommended_action,
-        "timmy_message": response.timmy_message,
-        "ui": {
-            "show_crisis_panel": response.show_crisis_panel,
-            "show_overlay": response.show_overlay,
-            "provide_988": response.provide_988,
-        },
-        "escalate": response.escalate,
-        "requires_human_review": image_result.requires_human_review,
-        "grounded_scope": image_result.grounded_scope,
-        "screening": image_result.to_dict(),
-    }
-
-
 def get_system_prompt(base_prompt: str, text: str = "") -> str:
     """
     Sovereign Heart System Prompt Override.

image_screening.py

@@ -1,195 +0,0 @@
-"""
-image_screening.py — local image crisis screening slice for epic #130.
-
-Grounded scope:
-- screens OCR text, upstream object labels, and operator notes for crisis signals
-- intentionally does NOT claim raw computer-vision understanding of pixels
-- designed to plug into future multimodal scoring once a dedicated image model lands
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Iterable, List, Optional
-
-from crisis.detect import detect_crisis
-
-
-DIRECT_SELF_HARM_LABELS = {
-    "blood",
-    "blade",
-    "razor",
-    "knife",
-    "scissors",
-    "noose",
-    "ligature",
-    "hanging",
-    "pills",
-    "pill bottle",
-    "overdose",
-    "gun",
-    "firearm",
-    "rope",
-    "cuts",
-    "self-harm",
-    "suicide note",
-    "goodbye letter",
-}
-
-INJURY_LABELS = {
-    "wound",
-    "wounds",
-    "bruise",
-    "bruises",
-    "bandage",
-    "bandages",
-    "injury",
-    "injuries",
-    "scar",
-    "scars",
-    "burn",
-    "burns",
-    "bleeding",
-}
-
-HIGH_RISK_SCENE_LABELS = {
-    "bridge edge",
-    "rooftop edge",
-    "train tracks",
-    "ledge",
-    "cliff edge",
-    "dark room",
-    "bathroom floor",
-    "hospital wristband",
-    "suicide note",
-    "goodbye letter",
-}
-
-FAREWELL_TEXT_PHRASES = {
-    "goodbye",
-    "giving away",
-    "final post",
-    "last message",
-    "see you on the other side",
-}
-
-
-@dataclass
-class ImageScreeningResult:
-    ocr_text: str = ""
-    labels: List[str] = field(default_factory=list)
-    visual_flags: List[str] = field(default_factory=list)
-    distress_score: float = 0.0
-    crisis_image_score: str = "safe"
-    requires_human_review: bool = False
-    signals_detected: List[str] = field(default_factory=list)
-    grounded_scope: str = (
-        "heuristic screening over OCR text, upstream labels, and operator notes; "
-        "raw vision-model inference is not implemented in this slice"
-    )
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-
-def _normalize_items(values: Optional[Iterable[str]]) -> List[str]:
-    if not values:
-        return []
-    normalized = []
-    for value in values:
-        text = str(value).strip().lower()
-        if text:
-            normalized.append(text)
-    return normalized
-
-
-def _match_keywords(haystack: str, keywords: set[str]) -> List[str]:
-    matches = []
-    for keyword in keywords:
-        if keyword in haystack:
-            matches.append(keyword)
-    return sorted(set(matches))
-
-
-def screen_image_signals(
-    image_path: Optional[str] = None,
-    *,
-    ocr_text: str = "",
-    labels: Optional[Iterable[str]] = None,
-    manual_notes: str = "",
-    visual_flags: Optional[Iterable[str]] = None,
-) -> ImageScreeningResult:
-    """
-    Score image-related crisis evidence without pretending to do full CV.
-
-    Inputs are deliberately grounded in what the repo can actually support today:
-    - OCR text extracted upstream from screenshots/photos
-    - object labels supplied by a local model or operator
-    - manual operator notes about visible scene context
-    - optional visual flags from any upstream preprocessor
-    """
-    normalized_labels = _normalize_items(labels)
-    normalized_flags = _normalize_items(visual_flags)
-    normalized_notes = str(manual_notes or "").strip().lower()
-    normalized_ocr = str(ocr_text or "").strip()
-
-    combined_label_text = " ".join(normalized_labels + normalized_flags + ([normalized_notes] if normalized_notes else []))
-    crisis_text = " ".join(part for part in [normalized_ocr, normalized_notes] if part).strip()
-
-    direct_matches = _match_keywords(combined_label_text, DIRECT_SELF_HARM_LABELS)
-    injury_matches = _match_keywords(combined_label_text, INJURY_LABELS)
-    scene_matches = _match_keywords(combined_label_text, HIGH_RISK_SCENE_LABELS)
-    farewell_matches = _match_keywords(crisis_text.lower(), FAREWELL_TEXT_PHRASES)
-    text_detection = detect_crisis(crisis_text) if crisis_text else None
-
-    signals: List[str] = []
-    score = 0.0
-
-    if direct_matches:
-        score = max(score, 0.85)
-        for match in direct_matches:
-            signals.append(f"direct_self_harm_label:{match}")
-
-    if injury_matches:
-        score = max(score, 0.55)
-        for match in injury_matches:
-            signals.append(f"injury_indicator:{match}")
-
-    if scene_matches:
-        score = max(score, 0.4)
-        for match in scene_matches:
-            signals.append(f"high_risk_scene:{match}")
-
-    if farewell_matches:
-        score = max(score, 0.85)
-        for match in farewell_matches:
-            signals.append(f"farewell_text:{match}")
-
-    if text_detection and text_detection.level != "NONE":
-        score = max(score, min(1.0, text_detection.score))
-        signals.append(f"ocr_crisis_level:{text_detection.level}")
-        for indicator in text_detection.indicators[:3]:
-            signals.append(f"ocr_indicator:{indicator}")
-
-    if direct_matches and text_detection and text_detection.level in {"HIGH", "CRITICAL"}:
-        score = min(1.0, max(score, 0.95))
-        signals.append("cross_modal_confirmation:text_plus_visual")
-
-    if direct_matches or (text_detection and text_detection.level == "CRITICAL") or score >= 0.85:
-        crisis_image_score = "critical"
-    elif score >= 0.4 or (text_detection and text_detection.level in {"HIGH", "MEDIUM"}):
-        crisis_image_score = "concerning"
-    else:
-        crisis_image_score = "safe"
-
-    requires_human_review = score >= 0.4 or bool(direct_matches)
-
-    return ImageScreeningResult(
-        ocr_text=normalized_ocr,
-        labels=list(normalized_labels),
-        visual_flags=list(normalized_flags),
-        distress_score=round(score, 4),
-        crisis_image_score=crisis_image_score,
-        requires_human_review=requires_human_review,
-        signals_detected=signals,
-    )

tests/test_footer_about_link.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+import re
+
+
+def test_footer_about_link_points_to_static_about_page() -> None:
+    index_html = Path("index.html").read_text(encoding="utf-8")
+
+    assert Path("about.html").exists(), "repo must ship a static about page"
+    assert 'aria-label="About The Door"' in index_html
+    assert 'href="/about.html"' in index_html, "footer link should resolve under a plain static server"
+    assert not re.search(r'href="/about"(?!\.html)', index_html), "stale /about route should not remain in the footer"

tests/test_image_screening.py

@@ -1,115 +0,0 @@
-"""Tests for local image crisis screening slice under epic #130."""
-
-import os
-import sys
-import unittest
-
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-
-from crisis.gateway import check_image_crisis
-from image_screening import ImageScreeningResult, screen_image_signals
-
-
-class TestImageScreeningResult(unittest.TestCase):
-    def test_to_dict_preserves_core_fields(self):
-        result = ImageScreeningResult(
-            ocr_text="help me",
-            labels=["blood"],
-            visual_flags=["dark_scene"],
-            distress_score=0.8,
-            requires_human_review=True,
-            signals_detected=["direct_self_harm_label:blood"],
-        )
-
-        data = result.to_dict()
-        self.assertEqual(data["ocr_text"], "help me")
-        self.assertEqual(data["labels"], ["blood"])
-        self.assertTrue(data["requires_human_review"])
-
-
-class TestScreenImageSignals(unittest.TestCase):
-    def test_direct_self_harm_labels_trigger_high_risk(self):
-        result = screen_image_signals(
-            labels=["razor blade", "blood droplets"],
-            manual_notes="photo of fresh cuts on forearm",
-        )
-
-        self.assertEqual(result.crisis_image_score, "critical")
-        self.assertGreaterEqual(result.distress_score, 0.8)
-        self.assertTrue(result.requires_human_review)
-        self.assertTrue(any("self_harm" in signal for signal in result.signals_detected))
-
-    def test_ocr_text_uses_existing_crisis_detector(self):
-        result = screen_image_signals(
-            ocr_text="I want to kill myself tonight",
-            labels=["handwritten note"],
-        )
-
-        self.assertGreaterEqual(result.distress_score, 0.7)
-        self.assertTrue(result.requires_human_review)
-        self.assertTrue(any(signal.startswith("ocr_crisis_level:") for signal in result.signals_detected))
-
-    def test_neutral_image_stays_low_risk(self):
-        result = screen_image_signals(
-            labels=["dog", "park", "sunlight"],
-            manual_notes="family outing in daylight",
-        )
-
-        self.assertEqual(result.crisis_image_score, "safe")
-        self.assertLess(result.distress_score, 0.2)
-        self.assertFalse(result.requires_human_review)
-        self.assertEqual(result.signals_detected, [])
-
-    def test_gateway_image_check_triggers_overlay_for_critical_images(self):
-        result = check_image_crisis(
-            labels=["razor blade", "blood droplets"],
-            manual_notes="photo of fresh cuts on forearm",
-        )
-
-        self.assertEqual(result["level"], "CRITICAL")
-        self.assertEqual(result["image_score"], "critical")
-        self.assertTrue(result["ui"]["show_overlay"])
-        self.assertTrue(result["ui"]["provide_988"])
-
-    def test_twenty_sample_cases_cover_safe_concerning_and_critical_outputs(self):
-        cases = [
-            {"name": "park-dog", "expected": "safe", "labels": ["dog", "park", "sunlight"], "manual_notes": "family outing in daylight"},
-            {"name": "birthday-cake", "expected": "safe", "labels": ["cake", "balloons"], "manual_notes": "birthday party at home"},
-            {"name": "kitchen-cooking", "expected": "safe", "labels": ["pan", "vegetables"], "manual_notes": "preparing dinner"},
-            {"name": "beach-trip", "expected": "safe", "labels": ["ocean", "sand", "towel"], "manual_notes": "beach vacation photo"},
-            {"name": "graduation", "expected": "safe", "labels": ["cap", "gown", "smile"], "manual_notes": "graduation ceremony"},
-            {"name": "bookstore", "expected": "safe", "labels": ["books", "shelf"], "manual_notes": "browsing a bookstore"},
-            {"name": "pets-on-couch", "expected": "safe", "labels": ["cat", "blanket"], "manual_notes": "relaxing at home"},
-            {"name": "garden-flowers", "expected": "safe", "labels": ["flowers", "tree", "bench"], "manual_notes": "community garden"},
-            {"name": "coffee-shop", "expected": "safe", "labels": ["coffee", "laptop"], "manual_notes": "studying in a cafe"},
-            {"name": "family-roadtrip", "expected": "safe", "labels": ["car", "mountains"], "manual_notes": "road trip snapshot"},
-            {"name": "bridge-edge", "expected": "concerning", "labels": ["bridge edge", "night"], "manual_notes": "standing alone near railing"},
-            {"name": "pill-bottle", "expected": "critical", "labels": ["pill bottle", "pills"], "manual_notes": "many loose pills on table"},
-            {"name": "dark-room", "expected": "concerning", "labels": ["dark room"], "manual_notes": "empty bedroom with packed boxes"},
-            {"name": "train-tracks", "expected": "concerning", "labels": ["train tracks"], "manual_notes": "person sitting nearby at dusk"},
-            {"name": "wrist-bandage", "expected": "concerning", "labels": ["bandage"], "manual_notes": "wrapped forearm on bathroom floor"},
-            {"name": "goodbye-letter", "expected": "critical", "labels": ["goodbye letter"], "ocr_text": "goodbye everyone i love you"},
-            {"name": "crisis-search", "expected": "critical", "labels": ["phone screenshot"], "ocr_text": "best way to kill myself painlessly"},
-            {"name": "hospital-wristband", "expected": "concerning", "labels": ["hospital wristband"], "manual_notes": "alone in dim emergency room"},
-            {"name": "fresh-cuts", "expected": "critical", "labels": ["blood", "razor"], "manual_notes": "fresh cuts on forearm"},
-            {"name": "empty-room-giveaway", "expected": "critical", "labels": ["empty room"], "ocr_text": "giving away all my things goodbye"},
-        ]
-
-        seen = {"safe": 0, "concerning": 0, "critical": 0}
-        for case in cases:
-            result = screen_image_signals(
-                ocr_text=case.get("ocr_text", ""),
-                labels=case.get("labels", []),
-                manual_notes=case.get("manual_notes", ""),
-            )
-            self.assertEqual(result.crisis_image_score, case["expected"], case["name"])
-            seen[case["expected"]] += 1
-
-        self.assertEqual(sum(seen.values()), 20)
-        self.assertEqual(seen["safe"], 10)
-        self.assertGreaterEqual(seen["concerning"], 5)
-        self.assertGreaterEqual(seen["critical"], 5)
-
-
-if __name__ == "__main__":
-    unittest.main()