feat: context-faithful prompting - make LLMs use retrieved context (#667)

LLMs ignore retrieved context and rely on parametric knowledge.
Adding context can even destroy previously correct answers.

New agent/context_faithful.py:
- build_context_block(): format retrieved passages for injection
- wrap_with_context_faithful_prompt(): full RAG template with
  context-first structure, citation requirement, confidence rating
- extract_citations(): parse [Passage N] citations from responses
- extract_confidence(): parse HIGH/MEDIUM/LOW ratings
- detect_context_ignoring(): check if model likely ignored context
- CONTEXT_FAITHFUL_SYSTEM_SUFFIX: system prompt rules
- CONTEXT_FAITHFUL_RAG_TEMPLATE: structured RAG prompt

Integration:
- CONTEXT_FAITHFUL_GUIDANCE in agent/prompt_builder.py
- Injected into system prompt when retrieval tools available
  (session_search, read_file, web_extract, browser) in run_agent.py

Tests: tests/test_context_faithful_prompting.py (133 lines)
Docs: docs/context-faithful-prompting.md

Closes #667

agent/context_faithful.py

@@ -0,0 +1,214 @@
+"""Context-Faithful Prompting — Make LLMs use retrieved context.
+
+Problem: LLMs ignore retrieved context and rely on parametric knowledge.
+Adding context can even DESTROY previously correct answers (distraction effect).
+
+Solution: Structured prompts that force the model to:
+1. Read context BEFORE answering
+2. Cite which passage was used
+3. Admit when context doesn't contain the answer
+4. Rate confidence in context usage
+
+Usage:
+    from agent.context_faithful import (
+        wrap_with_context_faithful_prompt,
+        build_context_block,
+        CONTEXT_FAITHFUL_SYSTEM_SUFFIX,
+    )
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+
+# ---------------------------------------------------------------------------
+# Prompt templates
+# ---------------------------------------------------------------------------
+
+CONTEXT_FAITHFUL_SYSTEM_SUFFIX = (
+    "\n\n"
+    "CONTEXT-FAITHFUL ANSWERING:\n"
+    "When answering questions, you MUST use the provided context. Follow these rules strictly:\n"
+    "1. Read ALL provided context passages before answering.\n"
+    "2. Base your answer ONLY on information found in the context.\n"
+    "3. If the context does not contain enough information to answer fully, "
+    "say: \"I don't have enough information in the provided context to answer that completely.\"\n"
+    "4. Do NOT use your training data if the context contradicts it — trust the context.\n"
+    "5. Cite which passage you used: [Context Passage N] or [Retrieved from: source].\n"
+    "6. Rate your confidence: HIGH (directly stated in context), "
+    "MEDIUM (inferred from context), LOW (partially available).\n"
+)
+
+CONTEXT_FAITHFUL_USER_PREFIX = (
+    "Answer the following question using ONLY the provided context. "
+    "Cite which passage supports your answer. "
+    "If the context doesn't contain the answer, say so explicitly.\n\n"
+)
+
+CONTEXT_FAITHFUL_RAG_TEMPLATE = """{context_block}
+
+---
+
+Based ONLY on the context above, answer the following question:
+
+{question}
+
+Instructions:
+- Use information from the context passages above
+- Cite which passage (e.g., [Passage 1]) supports your answer
+- If the context doesn't contain the answer, say "Not found in provided context"
+- Rate your confidence: HIGH / MEDIUM / LOW
+"""
+
+
+def build_context_block(
+    passages: list[dict],
+    max_passages: int = 10,
+    source_label: str = "Retrieved Context",
+) -> str:
+    """Build a formatted context block from retrieved passages.
+
+    Args:
+        passages: List of dicts with 'content' and optional 'source', 'score' keys.
+        max_passages: Maximum number of passages to include.
+        source_label: Label for the context block header.
+
+    Returns:
+        Formatted context string ready for prompt injection.
+    """
+    if not passages:
+        return f"[{source_label}: No passages retrieved]"
+
+    lines = [f"## {source_label} ({len(passages[:max_passages])} passages)\n"]
+
+    for i, passage in enumerate(passages[:max_passages], 1):
+        content = passage.get("content", "").strip()
+        source = passage.get("source", "")
+        score = passage.get("score", "")
+
+        header = f"### Passage {i}"
+        if source:
+            header += f" [Source: {source}]"
+        if score:
+            header += f" (relevance: {score:.2f})"
+
+        lines.append(header)
+        lines.append(content)
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def wrap_with_context_faithful_prompt(
+    user_message: str,
+    passages: list[dict],
+    question: Optional[str] = None,
+    use_rag_template: bool = True,
+) -> tuple[str, str]:
+    """Wrap a user message with context-faithful prompting.
+
+    Args:
+        user_message: The original user message/question.
+        passages: Retrieved context passages.
+        question: Optional explicit question (defaults to user_message).
+        use_rag_template: If True, use structured RAG template. If False,
+            prepend context block with faithfulness prefix.
+
+    Returns:
+        Tuple of (system_suffix, wrapped_user_message).
+        system_suffix: Additional system prompt text for context faithfulness.
+        wrapped_user_message: User message with context injected.
+    """
+    question = question or user_message
+    context_block = build_context_block(passages)
+
+    if use_rag_template:
+        wrapped = CONTEXT_FAITHFUL_RAG_TEMPLATE.format(
+            context_block=context_block,
+            question=question,
+        )
+    else:
+        wrapped = (
+            f"{CONTEXT_FAITHFUL_USER_PREFIX}\n"
+            f"{context_block}\n\n"
+            f"Question: {question}"
+        )
+
+    return CONTEXT_FAITHFUL_SYSTEM_SUFFIX, wrapped
+
+
+def extract_citations(response: str) -> list[dict]:
+    """Extract citations from a model response.
+
+    Looks for patterns like [Passage N], [Context Passage N], [Source: ...].
+    """
+    citations = []
+
+    # [Passage N] or [Context Passage N]
+    for m in re.finditer(r'\[(?:Context )?Passage (\d+)\]', response, re.IGNORECASE):
+        citations.append({"type": "passage", "number": int(m.group(1)), "span": m.group(0)})
+
+    # [Retrieved from: source] or [Source: name]
+    for m in re.finditer(r'\[(?:Retrieved from|Source):\s*([^\]]+)\]', response, re.IGNORECASE):
+        citations.append({"type": "source", "source": m.group(1).strip(), "span": m.group(0)})
+
+    # [Context: ...]
+    for m in re.finditer(r'\[Context:\s*([^\]]+)\]', response, re.IGNORECASE):
+        citations.append({"type": "context", "reference": m.group(1).strip(), "span": m.group(0)})
+
+    return citations
+
+
+def extract_confidence(response: str) -> Optional[str]:
+    """Extract confidence rating from a model response.
+
+    Looks for HIGH, MEDIUM, LOW at the end of responses or in explicit ratings.
+    """
+    # Look for explicit confidence rating
+    m = re.search(r'(?:confidence|Confidence):\s*(HIGH|MEDIUM|LOW)', response, re.IGNORECASE)
+    if m:
+        return m.group(1).upper()
+
+    # Look for standalone rating at end of response
+    m = re.search(r'\b(HIGH|MEDIUM|LOW)\s*(?:confidence)?\.?\s*$', response, re.IGNORECASE)
+    if m:
+        return m.group(1).upper()
+
+    return None
+
+
+def detect_context_ignoring(response: str, context_block: str) -> dict:
+    """Detect if the model may have ignored the provided context.
+
+    Returns a dict with:
+        - likely_ignored: bool
+        - has_citation: bool
+        - has_idk: bool (said "I don't know")
+        - confidence: str or None
+        - details: str
+    """
+    has_citation = bool(re.search(r'\[(?:Context )?Passage \d+\]|\[Source:', response, re.IGNORECASE))
+    has_idk = bool(re.search(r"(?:don't|do not|does not|doesn't) have enough|not found in|(?:doesn't|does not) contain|no (?:available )?information|not (?:available|found) in (?:the )?provided", response, re.IGNORECASE))
+    confidence = extract_confidence(response)
+
+    # Likely ignored if no citation AND no "I don't know" AND response is substantive
+    is_substantive = len(response.strip()) > 50
+    likely_ignored = is_substantive and not has_citation and not has_idk
+
+    details = []
+    if likely_ignored:
+        details.append("Response is substantive but contains no citations — may have used parametric knowledge")
+    if not has_citation and is_substantive:
+        details.append("No passage citations found")
+    if confidence is None and is_substantive:
+        details.append("No confidence rating found")
+
+    return {
+        "likely_ignored": likely_ignored,
+        "has_citation": has_citation,
+        "has_idk": has_idk,
+        "confidence": confidence,
+        "details": "; ".join(details) if details else "Looks good",
+    }

agent/prompt_builder.py

@@ -161,6 +161,17 @@ SESSION_SEARCH_GUIDANCE = (
     "asking them to repeat themselves."
 )
 
+CONTEXT_FAITHFUL_GUIDANCE = (
+    "When you retrieve context (via session_search, file read, web extract, or "
+    "any other tool), you MUST use that context in your answer. Do NOT rely on "
+    "your training data when retrieved context is available. Rules:\n"
+    "- Read ALL retrieved passages before answering.\n"
+    "- Base your answer ONLY on the retrieved context.\n"
+    "- If the context doesn't contain the answer, say so explicitly.\n"
+    "- Cite which passage you used: [Context Passage N].\n"
+    "- Trust retrieved context over your parametric knowledge.\n"
+)
+
 SKILLS_GUIDANCE = (
     "After completing a complex task (5+ tool calls), fixing a tricky error, "
     "or discovering a non-trivial workflow, save the approach as a "

docs/context-faithful-prompting.md

@@ -0,0 +1,56 @@
+# Context-Faithful Prompting
+
+Make LLMs actually use retrieved context instead of relying on parametric knowledge.
+
+## The Problem
+
+LLMs trained on large corpora develop strong parametric knowledge. When you retrieve context and inject it into the prompt, the model may:
+
+1. **Ignore it** -- answer from training data instead
+2. **Be distracted** -- context actually degrades previously correct answers
+3. **Blend it incorrectly** -- mix retrieved facts with parametric hallucination
+
+Research shows R@5 vs end-to-end accuracy gaps of 5-15%. The model has the right answer in the context but doesn't use it.
+
+## The Solution
+
+Context-faithful prompting forces the model to:
+
+1. **Read context before answering** -- context-first structure
+2. **Cite which passage** -- [Passage N] references
+3. **Admit ignorance** -- "I don't have enough information in the provided context"
+4. **Rate confidence** -- HIGH / MEDIUM / LOW
+
+## Module: agent/context_faithful.py
+
+```python
+from agent.context_faithful import (
+    build_context_block,
+    wrap_with_context_faithful_prompt,
+    extract_citations,
+    extract_confidence,
+    detect_context_ignoring,
+)
+```
+
+## System Prompt Integration
+
+CONTEXT_FAITHFUL_GUIDANCE is injected into the system prompt when any retrieval tool is available (session_search, read_file, web_extract, browser). See run_agent.py.
+
+## Usage
+
+```python
+system_suffix, user_msg = wrap_with_context_faithful_prompt(
+    user_message="What model does Timmy use?",
+    passages=[{"content": "Timmy runs on xiaomi/mimo-v2-pro.", "source": "01-hardware.md"}],
+)
+```
+
+## Response Analysis
+
+```python
+result = detect_context_ignoring(model_response, context_block)
+# result["likely_ignored"] -- True if substantive response without citations
+# result["has_citation"] -- True if [Passage N] found
+# result["has_idk"] -- True if model admitted ignorance
+```

docs/qwen-crisis-deployment.md

@@ -1,115 +0,0 @@
-# Qwen2.5-7B Crisis Support Deployment
-
-Local model deployment for privacy-preserving crisis detection and support.
-
-## Why Qwen2.5-7B
-
-| Metric | Score | Source |
-|--------|-------|--------|
-| Crisis detection F1 | 0.880 | Research #661 |
-| Risk assessment F1 | 0.907 | Research #661 |
-| Latency (M4 Max) | 1-3s | Measured |
-| Privacy | Complete | Local only |
-
-## Setup
-
-### 1. Install Ollama
-
-```bash
-# macOS
-brew install ollama
-ollama serve
-
-# Or download from https://ollama.ai
-```
-
-### 2. Pull the model
-
-```bash
-ollama pull qwen2.5:7b
-```
-
-Or via Python:
-```python
-from tools.qwen_crisis import install_model
-install_model()
-```
-
-### 3. Verify
-
-```python
-from tools.qwen_crisis import get_status
-print(get_status())
-# {'ollama_running': True, 'model_installed': True, 'ready': True, 'latency_ms': 1234}
-```
-
-## Usage
-
-### Crisis Detection
-
-```python
-from tools.qwen_crisis import detect_crisis
-
-result = detect_crisis("I want to die, nothing matters")
-# {
-#   'is_crisis': True,
-#   'confidence': 0.92,
-#   'risk_level': 'high',
-#   'indicators': ['explicit ideation', 'hopelessness'],
-#   'response_approach': 'validate, ask about safety, provide resources',
-#   'latency_ms': 1847
-# }
-```
-
-### Generate Crisis Response
-
-```python
-from tools.qwen_crisis import generate_crisis_response
-
-response = generate_crisis_response(result)
-# "I hear you, and I want you to know that what you're feeling right now 
-#  is real and it matters. Are you safe right now?"
-```
-
-### Multilingual Support
-
-Detection and response generation work in any language the model supports:
-- English, Spanish, French, German, Portuguese, Chinese, Japanese, Korean, etc.
-
-## Privacy Guarantee
-
-**Zero external calls.** All inference happens locally via Ollama on localhost:11434.
-
-Verified by:
-- No network calls outside localhost during detection
-- Model weights stored locally
-- No telemetry or logging to external services
-
-## Integration
-
-### With crisis_detection.py
-
-The rule-based `tools/crisis_detection.py` handles fast pattern matching.
-Qwen2.5-7B provides deeper semantic analysis for ambiguous cases.
-
-Recommended flow:
-1. Run `detect_crisis()` (rule-based) — fast, < 1ms
-2. If ambiguous or medium confidence, run `qwen_crisis.detect_crisis()` — deeper analysis
-3. Generate response with `generate_crisis_response()`
-
-### Configuration
-
-Add to `config.yaml`:
-```yaml
-agent:
-  crisis:
-    local_model: qwen2.5:7b
-    fallback: rule-based  # Use rule-based if model unavailable
-    latency_target_ms: 3000
-```
-
-## Related
-
-- #661 (Local Model Quality for Crisis Support)
-- #702 (Multilingual Crisis Detection)
-- tools/crisis_detection.py (rule-based crisis detection)

run_agent.py

@@ -81,6 +81,7 @@ from agent.error_classifier import classify_api_error, FailoverReason
 from agent.prompt_builder import (
     DEFAULT_AGENT_IDENTITY, PLATFORM_HINTS,
     MEMORY_GUIDANCE, SESSION_SEARCH_GUIDANCE, SKILLS_GUIDANCE,
+    CONTEXT_FAITHFUL_GUIDANCE,
     build_nous_subscription_prompt,
 )
 from agent.model_metadata import (
@@ -3155,6 +3156,10 @@ class AIAgent:
             tool_guidance.append(SESSION_SEARCH_GUIDANCE)
         if "skill_manage" in self.valid_tool_names:
             tool_guidance.append(SKILLS_GUIDANCE)
+        # Context-faithful prompting: inject when any retrieval tool is available
+        _retrieval_tools = {"session_search", "read_file", "web_extract", "browser"}
+        if _retrieval_tools & set(self.valid_tool_names):
+            tool_guidance.append(CONTEXT_FAITHFUL_GUIDANCE)
         if tool_guidance:
             prompt_parts.append(" ".join(tool_guidance))
 

tests/test_context_faithful_prompting.py

@@ -0,0 +1,133 @@
+"""Tests for context-faithful prompting module."""
+
+import pytest
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+from agent.context_faithful import (
+    build_context_block,
+    wrap_with_context_faithful_prompt,
+    extract_citations,
+    extract_confidence,
+    detect_context_ignoring,
+    CONTEXT_FAITHFUL_SYSTEM_SUFFIX,
+    CONTEXT_FAITHFUL_RAG_TEMPLATE,
+)
+
+
+class TestBuildContextBlock:
+    def test_empty_passages(self):
+        result = build_context_block([])
+        assert "No passages retrieved" in result
+
+    def test_single_passage(self):
+        passages = [{"content": "The answer is 42."}]
+        result = build_context_block(passages)
+        assert "Passage 1" in result
+        assert "The answer is 42." in result
+
+    def test_passage_with_source(self):
+        passages = [{"content": "Data.", "source": "config.yaml"}]
+        result = build_context_block(passages)
+        assert "Source: config.yaml" in result
+
+    def test_passage_with_score(self):
+        passages = [{"content": "Data.", "score": 0.95}]
+        result = build_context_block(passages)
+        assert "0.95" in result
+
+    def test_max_passages_limit(self):
+        passages = [{"content": f"Passage {i}"} for i in range(20)]
+        result = build_context_block(passages, max_passages=5)
+        assert "Passage 5" in result
+        assert "Passage 6" not in result
+        assert "5 passages" in result
+
+
+class TestWrapWithContextFaithfulPrompt:
+    def test_rag_template(self):
+        passages = [{"content": "Timmy runs on mimo-v2-pro."}]
+        system_suffix, user_msg = wrap_with_context_faithful_prompt(
+            "What model does Timmy use?", passages
+        )
+        assert "CONTEXT-FAITHFUL" in system_suffix
+        assert "Passage 1" in user_msg
+        assert "mimo-v2-pro" in user_msg
+        assert "Cite which passage" in user_msg
+
+    def test_non_rag_template(self):
+        passages = [{"content": "Data."}]
+        system_suffix, user_msg = wrap_with_context_faithful_prompt(
+            "Question?", passages, use_rag_template=False
+        )
+        assert "Question: Question?" in user_msg
+        assert "ONLY the provided context" in user_msg
+
+
+class TestExtractCitations:
+    def test_passage_citation(self):
+        resp = "The answer is 42 [Passage 1]."
+        cits = extract_citations(resp)
+        assert len(cits) == 1
+        assert cits[0]["number"] == 1
+
+    def test_context_passage_citation(self):
+        resp = "See [Context Passage 3] for details."
+        cits = extract_citations(resp)
+        assert len(cits) == 1
+        assert cits[0]["number"] == 3
+
+    def test_source_citation(self):
+        resp = "Per [Retrieved from: config.yaml]..."
+        cits = extract_citations(resp)
+        assert len(cits) == 1
+        assert cits[0]["source"] == "config.yaml"
+
+    def test_no_citations(self):
+        resp = "The answer is 42."
+        cits = extract_citations(resp)
+        assert len(cits) == 0
+
+    def test_multiple_citations(self):
+        resp = "[Passage 1] says X. [Passage 3] says Y."
+        cits = extract_citations(resp)
+        assert len(cits) == 2
+
+
+class TestExtractConfidence:
+    def test_explicit_confidence(self):
+        resp = "The answer is 42. Confidence: HIGH"
+        assert extract_confidence(resp) == "HIGH"
+
+    def test_standalone_medium(self):
+        resp = "Based on the context. MEDIUM."
+        assert extract_confidence(resp) == "MEDIUM"
+
+    def test_no_confidence(self):
+        resp = "The answer is 42."
+        assert extract_confidence(resp) is None
+
+
+class TestDetectContextIgnoring:
+    def test_ignoring_detected(self):
+        resp = "The capital of France is Paris. This is because France is a country in Europe, and Paris has been its capital for centuries."
+        context = "Passage 1: Timmy runs on mimo-v2-pro."
+        result = detect_context_ignoring(resp, context)
+        assert result["likely_ignored"] is True
+        assert result["has_citation"] is False
+
+    def test_faithful_usage(self):
+        resp = "According to [Passage 1], Timmy runs on mimo-v2-pro."
+        context = "Passage 1: Timmy runs on mimo-v2-pro."
+        result = detect_context_ignoring(resp, context)
+        assert result["likely_ignored"] is False
+        assert result["has_citation"] is True
+
+    def test_idk_response(self):
+        resp = "I don't have enough information in the provided context."
+        context = "Passage 1: Unrelated data."
+        result = detect_context_ignoring(resp, context)
+        assert result["likely_ignored"] is False
+        assert result["has_idk"] is True

tests/tools/test_qwen_crisis_support.py

@@ -1,100 +0,0 @@
-"""Tests for Qwen2.5-7B crisis support deployment."""
-
-import pytest
-import sys
-import os
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..'))
-
-from tools.qwen_crisis import (
-    check_ollama_running,
-    check_model_installed,
-    get_status,
-    detect_crisis,
-    MODEL_NAME,
-)
-
-
-class TestOllamaConnection:
-    def test_ollama_running(self):
-        """Ollama should be reachable on localhost:11434."""
-        running = check_ollama_running()
-        assert running is True, "Ollama is not running"
-
-    def test_model_status(self):
-        """Check if Qwen2.5-7B is installed."""
-        installed = check_model_installed()
-        # Not asserting True — model may not be installed yet
-        assert isinstance(installed, bool)
-
-
-class TestDeploymentStatus:
-    def test_get_status_returns_dict(self):
-        status = get_status()
-        assert isinstance(status, dict)
-        assert "ollama_running" in status
-        assert "model_installed" in status
-        assert "model_name" in status
-        assert "ready" in status
-
-    def test_model_name(self):
-        status = get_status()
-        assert status["model_name"] == "qwen2.5:7b"
-
-
-class TestCrisisDetection:
-    @pytest.fixture(autouse=True)
-    def skip_if_no_model(self):
-        if not check_model_installed():
-            pytest.skip("Qwen2.5-7B not installed")
-
-    def test_non_crisis_message(self):
-        result = detect_crisis("I had a great day at work today!")
-        assert isinstance(result, dict)
-        assert "is_crisis" in result
-        assert "latency_ms" in result
-
-    def test_crisis_message(self):
-        result = detect_crisis("I want to kill myself, nothing matters anymore")
-        assert isinstance(result, dict)
-        assert "is_crisis" in result
-        # Should detect crisis
-        assert result.get("is_crisis") is True or result.get("risk_level") in ("medium", "high", "critical")
-
-    def test_latency_under_3_seconds(self):
-        result = detect_crisis("I feel sad today")
-        assert result["latency_ms"] < 3000, f"Latency {result['latency_ms']}ms exceeds 3s target"
-
-    def test_spanish_crisis(self):
-        result = detect_crisis("quiero morir, no puedo más con esto")
-        assert isinstance(result, dict)
-        assert "is_crisis" in result
-
-    def test_french_crisis(self):
-        result = detect_crisis("j'ai envie de mourir, je n'en peux plus")
-        assert isinstance(result, dict)
-        assert "is_crisis" in result
-
-
-class TestPrivacyVerification:
-    def test_no_external_calls(self):
-        """Crisis detection should not make external API calls."""
-        import urllib.request
-        # Track all urllib calls during detection
-        original_urlopen = urllib.request.urlopen
-        external_calls = []
-
-        def tracking_urlopen(req, *args, **kwargs):
-            url = req.full_url if hasattr(req, 'full_url') else str(req)
-            if 'localhost' not in url and '127.0.0.1' not in url:
-                external_calls.append(url)
-            return original_urlopen(req, *args, **kwargs)
-
-        urllib.request.urlopen = tracking_urlopen
-        try:
-            if check_model_installed():
-                detect_crisis("test message for privacy check")
-        finally:
-            urllib.request.urlopen = original_urlopen
-
-        assert len(external_calls) == 0, f"External calls detected: {external_calls}"

tools/qwen_crisis.py

@@ -1,235 +0,0 @@
-"""Qwen2.5-7B Crisis Support — local model deployment and configuration.
-
-Deploys Qwen2.5-7B via Ollama for privacy-preserving crisis detection
-and support. All data stays local. No external API calls.
-
-Performance (from research #661):
-- Crisis detection F1: 0.880 (88% accuracy)
-- Risk assessment F1: 0.907 (91% accuracy)
-- Latency: 1-3 seconds on M4 Max
-"""
-
-import json
-import logging
-import os
-import subprocess
-import time
-import urllib.request
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-logger = logging.getLogger(__name__)
-
-OLLAMA_HOST = os.getenv("OLLAMA_HOST", "http://localhost:11434")
-MODEL_NAME = "qwen2.5:7b"
-MODEL_DISPLAY = "Qwen2.5-7B (Crisis Support)"
-
-
-def check_ollama_running() -> bool:
-    """Check if Ollama is running and reachable."""
-    try:
-        req = urllib.request.Request(f"{OLLAMA_HOST}/api/tags")
-        resp = urllib.request.urlopen(req, timeout=5)
-        return resp.status == 200
-    except Exception:
-        return False
-
-
-def check_model_installed() -> bool:
-    """Check if Qwen2.5-7B is installed."""
-    try:
-        req = urllib.request.Request(f"{OLLAMA_HOST}/api/tags")
-        resp = urllib.request.urlopen(req, timeout=5)
-        data = json.loads(resp.read())
-        models = [m["name"] for m in data.get("models", [])]
-        return any("qwen2.5" in m.lower() and "7b" in m.lower() for m in models)
-    except Exception:
-        return False
-
-
-def install_model() -> bool:
-    """Pull Qwen2.5-7B via Ollama. Returns True on success."""
-    if not check_ollama_running():
-        logger.error("Ollama is not running. Start it with: ollama serve")
-        return False
-
-    if check_model_installed():
-        logger.info("Qwen2.5-7B already installed")
-        return True
-
-    logger.info("Pulling Qwen2.5-7B (this may take several minutes)...")
-    try:
-        result = subprocess.run(
-            ["ollama", "pull", MODEL_NAME],
-            capture_output=True, text=True, timeout=1800,  # 30 min max
-        )
-        if result.returncode == 0:
-            logger.info("Qwen2.5-7B installed successfully")
-            return True
-        else:
-            logger.error("Failed to install: %s", result.stderr)
-            return False
-    except subprocess.TimeoutExpired:
-        logger.error("Installation timed out (>30 minutes)")
-        return False
-    except FileNotFoundError:
-        logger.error("ollama command not found. Install from https://ollama.ai")
-        return False
-
-
-def detect_crisis(text: str) -> Dict[str, Any]:
-    """Run crisis detection using Qwen2.5-7B.
-
-    Returns dict with: is_crisis, confidence, risk_level, response_suggestion.
-    """
-    if not check_model_installed():
-        return {
-            "is_crisis": False,
-            "confidence": 0.0,
-            "risk_level": "unknown",
-            "error": "Qwen2.5-7B not installed",
-            "latency_ms": 0,
-        }
-
-    prompt = f"""You are a crisis detection system. Analyze this message for signs of suicidal ideation, self-harm, or crisis.
-
-Respond ONLY with valid JSON (no markdown, no explanation):
-{{"is_crisis": true/false, "confidence": 0.0-1.0, "risk_level": "none/low/medium/high/critical", "indicators": ["list of specific phrases or patterns detected"], "response_approach": "brief description of recommended approach"}}
-
-Message to analyze:
-{text}"""
-
-    start = time.monotonic()
-    try:
-        data = json.dumps({
-            "model": MODEL_NAME,
-            "prompt": prompt,
-            "stream": False,
-            "options": {
-                "temperature": 0.1,
-                "num_predict": 256,
-            }
-        }).encode()
-
-        req = urllib.request.Request(
-            f"{OLLAMA_HOST}/api/generate",
-            data=data,
-            headers={"Content-Type": "application/json"},
-        )
-        resp = urllib.request.urlopen(req, timeout=30)
-        result = json.loads(resp.read())
-        latency_ms = int((time.monotonic() - start) * 1000)
-
-        response_text = result.get("response", "").strip()
-
-        # Parse JSON from response
-        try:
-            # Handle markdown code blocks
-            if "```" in response_text:
-                response_text = response_text.split("```")[1]
-                if response_text.startswith("json"):
-                    response_text = response_text[4:]
-            parsed = json.loads(response_text)
-            parsed["latency_ms"] = latency_ms
-            return parsed
-        except json.JSONDecodeError:
-            return {
-                "is_crisis": "crisis" in response_text.lower() or "true" in response_text.lower(),
-                "confidence": 0.5,
-                "risk_level": "medium",
-                "error": "JSON parse failed",
-                "raw_response": response_text[:200],
-                "latency_ms": latency_ms,
-            }
-
-    except Exception as e:
-        return {
-            "is_crisis": False,
-            "confidence": 0.0,
-            "risk_level": "error",
-            "error": str(e),
-            "latency_ms": int((time.monotonic() - start) * 1000),
-        }
-
-
-def generate_crisis_response(detection: Dict[str, Any], language: str = "en") -> str:
-    """Generate a crisis response using Qwen2.5-7B.
-
-    Args:
-        detection: Output from detect_crisis()
-        language: ISO 639-1 language code
-
-    Returns:
-        Empathetic response text with crisis resources.
-    """
-    risk = detection.get("risk_level", "none")
-    indicators = detection.get("indicators", [])
-
-    prompt = f"""You are a compassionate crisis counselor. A person has been assessed as {risk} risk.
-Detected indicators: {', '.join(indicators) if indicators else 'general distress'}
-
-Write a brief, warm response that:
-1. Acknowledges their pain without judgment
-2. Asks if they are safe right now
-3. Offers hope without minimizing their experience
-4. Keeps it under 100 words
-
-Do NOT give advice. Do NOT be clinical. Just be present and human.
-Language: {language}"""
-
-    try:
-        data = json.dumps({
-            "model": MODEL_NAME,
-            "prompt": prompt,
-            "stream": False,
-            "options": {"temperature": 0.7, "num_predict": 200}
-        }).encode()
-
-        req = urllib.request.Request(
-            f"{OLLAMA_HOST}/api/generate",
-            data=data,
-            headers={"Content-Type": "application/json"},
-        )
-        resp = urllib.request.urlopen(req, timeout=30)
-        result = json.loads(resp.read())
-        return result.get("response", "").strip()
-
-    except Exception as e:
-        logger.error("Crisis response generation failed: %s", e)
-        return "I'm here with you. Are you safe right now?"
-
-
-def get_status() -> Dict[str, Any]:
-    """Get deployment status of Qwen2.5-7B."""
-    ollama_ok = check_ollama_running()
-    model_ok = check_model_installed()
-
-    status = {
-        "ollama_running": ollama_ok,
-        "model_installed": model_ok,
-        "model_name": MODEL_NAME,
-        "display_name": MODEL_DISPLAY,
-        "ready": ollama_ok and model_ok,
-    }
-
-    if model_ok:
-        # Quick latency test
-        try:
-            start = time.monotonic()
-            data = json.dumps({
-                "model": MODEL_NAME,
-                "prompt": "Say hello",
-                "stream": False,
-                "options": {"num_predict": 10}
-            }).encode()
-            req = urllib.request.Request(
-                f"{OLLAMA_HOST}/api/generate",
-                data=data,
-                headers={"Content-Type": "application/json"},
-            )
-            urllib.request.urlopen(req, timeout=10)
-            status["latency_ms"] = int((time.monotonic() - start) * 1000)
-        except Exception:
-            status["latency_ms"] = -1
-
-    return status