fix: implementation for #711

Crisis hook now logs at appropriate level based on confidence:
- WARNING for high confidence (>=0.9) — direct mentions like 988, suicide
- INFO for lower confidence (<0.9) — indirect signals like hopelessness

This reduces log noise while preserving visibility for clear crisis signals.

Fixes #711

agent/crisis_hook.py

@@ -0,0 +1,100 @@
+"""Crisis detection hook — Issue #677, #711.
+
+Detects crisis signals in user messages and returns 988 Lifeline resources.
+Called early in conversation loop before other processing.
+
+Fix #711: Only log warning for high-confidence detections (>=0.9).
+Lower confidence matches log info level to reduce noise.
+"""
+
+import logging
+import re
+from typing import Optional, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+_PATTERNS = [
+    (r'\b(988|suicide|suicidal)\b', "direct"),
+    (r'\b(kill myself|end my life|want to die|better off dead)\b', "ideation"),
+    (r'\b(self.harm|self.hurt|cutting myself)\b', "self_harm"),
+    (r'\b(no reason to live|can.t go on|give up on life)\b', "hopeless"),
+    (r'\b(planning to|going to) (end|kill|hurt)\b', "planning"),
+]
+
+_THRESHOLD = 0.7
+_HIGH_CONFIDENCE = 0.9
+
+_RESPONSE = """I hear you, and you're not alone.
+
+**If in immediate danger, call 911.**
+
+**988 Suicide & Crisis Lifeline:**
+- **Call or text 988** (US)
+- **Chat:** 988lifeline.org/chat
+- **Español:** 1-888-628-9454
+
+**Crisis Text Line:**
+- **Text HOME to 741741**
+
+**International:**
+- https://www.iasp.info/resources/Crisis_Centres/
+
+You matter. Help is available 24/7.
+
+I'm an AI, not a crisis counselor, but I can listen."""
+
+
+def _confidence(msg: str, ptype: str) -> float:
+    base = {"direct": 0.95, "ideation": 0.9, "self_harm": 0.85,
+            "hopeless": 0.7, "planning": 0.95}.get(ptype, 0.5)
+    matches = sum(1 for p, _ in _PATTERNS if re.search(p, msg.lower(), re.I))
+    if matches > 1:
+        base = min(1.0, base + 0.1 * (matches - 1))
+    return base
+
+
+def check_crisis(message: str) -> Optional[Dict[str, Any]]:
+    """Check message for crisis signals. Returns dict or None."""
+    if not message or not message.strip():
+        return None
+    msg_lower = message.lower()
+    best, best_c = None, 0.0
+    for pattern, ptype in _PATTERNS:
+        if re.search(pattern, msg_lower, re.I):
+            c = _confidence(message, ptype)
+            if c > best_c:
+                best_c, best = c, ptype
+    if best_c < _THRESHOLD:
+        return None
+    return {"detected": True, "confidence": best_c, "pattern_type": best, "response": _RESPONSE}
+
+
+def log_crisis_detection(session_id: str, crisis_result: Dict[str, Any]) -> None:
+    """Log crisis detection at appropriate level based on confidence.
+    
+    Fix #711: Only log WARNING for high-confidence (>=0.9).
+    Log INFO for lower confidence to reduce noise.
+    """
+    confidence = crisis_result.get("confidence", 0.0)
+    pattern_type = crisis_result.get("pattern_type", "unknown")
+    
+    if confidence >= _HIGH_CONFIDENCE:
+        logger.warning(
+            "Crisis detected: session=%s type=%s confidence=%.2f",
+            session_id or "none", pattern_type, confidence
+        )
+    else:
+        logger.info(
+            "Crisis signal (low confidence): session=%s type=%s confidence=%.2f",
+            session_id or "none", pattern_type, confidence
+        )
+
+
+def is_crisis_message(message: str) -> bool:
+    r = check_crisis(message)
+    return r is not None and r["detected"]
+
+
+def get_crisis_response(message: str) -> Optional[str]:
+    r = check_crisis(message)
+    return r["response"] if r and r["detected"] else None

run_agent.py

@@ -7882,6 +7882,27 @@ class AIAgent:
         messages.append(user_msg)
         current_turn_user_idx = len(messages) - 1
         self._persist_user_message_idx = current_turn_user_idx
+
+        # Crisis detection — Issue #677, #711
+        # Check for crisis signals before other processing. If detected,
+        # return the 988 Lifeline response immediately.
+        # Fix #711: Use log_crisis_detection() to log at appropriate level.
+        try:
+            from agent.crisis_hook import check_crisis, log_crisis_detection
+            _crisis = check_crisis(user_message)
+            if _crisis and _crisis.get("detected"):
+                _resp = _crisis.get("response", "")
+                if _resp:
+                    log_crisis_detection(self.session_id, _crisis)
+                    return {
+                        "final_response": _resp,
+                        "messages": messages + [{"role": "assistant", "content": _resp}],
+                        "iterations_used": 0, "tool_calls_made": 0, "crisis_detected": True,
+                    }
+        except ImportError:
+            pass
+        except Exception as e:
+            logger.debug("Crisis check failed: %s", e)
         
         if not self.quiet_mode:
             self._safe_print(f"💬 Starting conversation: '{user_message[:60]}{'...' if len(user_message) > 60 else ''}'")

tests/test_crisis_hook_logging.py

@@ -0,0 +1,59 @@
+"""Tests for crisis_hook logging behavior — Issue #711."""
+import logging
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from agent.crisis_hook import check_crisis, log_crisis_detection
+
+
+class TestLogLevels:
+    """Verify warning only for high confidence, info for low."""
+    
+    def test_high_confidence_logs_warning(self, caplog):
+        """Direct crisis mention (confidence >= 0.9) should log WARNING."""
+        with caplog.at_level(logging.INFO):
+            result = check_crisis("I'm feeling suicidal")
+            assert result is not None
+            assert result["confidence"] >= 0.9
+            log_crisis_detection("test-session", result)
+        
+        assert any(r.levelno == logging.WARNING for r in caplog.records)
+        assert any("Crisis detected" in r.message for r in caplog.records)
+    
+    def test_low_confidence_logs_info(self, caplog):
+        """Indirect signal (confidence < 0.9) should log INFO, not WARNING."""
+        with caplog.at_level(logging.INFO):
+            result = check_crisis("I have no reason to live")
+            if result and result["confidence"] < 0.9:
+                log_crisis_detection("test-session", result)
+                assert any(r.levelno == logging.INFO for r in caplog.records)
+                assert not any(r.levelno == logging.WARNING for r in caplog.records)
+    
+    def test_988_direct_logs_warning(self, caplog):
+        """Direct 988 mention should log WARNING (high confidence)."""
+        with caplog.at_level(logging.INFO):
+            result = check_crisis("I need to call 988")
+            assert result["confidence"] >= 0.9
+            log_crisis_detection("test-session", result)
+        
+        warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
+        assert len(warnings) >= 1
+
+
+class TestCrisisDetection:
+    """Basic detection still works."""
+    
+    def test_suicide_detected(self):
+        r = check_crisis("feeling suicidal"); assert r and r["detected"]
+    
+    def test_normal_not_detected(self):
+        assert check_crisis("hello world") is None
+    
+    def test_empty_not_detected(self):
+        assert check_crisis("") is None
+
+
+if __name__ == "__main__":
+    import pytest
+    pytest.main([__file__, "-v"])