humane-proxy 0.3.0__tar.gz → 0.3.1__tar.gz

{humane_proxy-0.3.0/humane_proxy.egg-info → humane_proxy-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: humane-proxy
-Version: 0.3.0
+Version: 0.3.1
 Summary: Lightweight, plug-and-play AI safety middleware that protects humans.
 Author-email: Vishisht Mishra <Vishisht16@users.noreply.github.com>
 License: Apache-2.0
@@ -186,6 +186,8 @@ stage2:
   safe_threshold: 0.35         # cosine similarity below this → safe
 ```
 
+> **Multilingual Support:** If your users converse in non-English languages (Roman Hindi, Spanish, Arabic, etc.), change the `model` in your configuration to `"paraphrase-multilingual-MiniLM-L12-v2"`. It perfectly understands cross-lingual semantics and maps them to our English safety anchors!
+
 The model lazy-loads on first use. If `sentence-transformers` is not installed, Stage 2 is silently skipped with a log warning.
 
 > **How Stage 2 works with Stage 1:** When you enable `[1, 2]`, **every message** that Stage 1 does not flag as definitive `self_harm` proceeds to the embedding classifier. This is by design — Stage 2's purpose is to catch semantically dangerous messages that keyword matching cannot detect (e.g. *"Nobody would notice if I disappeared"*). Stage 1 acts as a fast-path optimisation for clear-cut cases, not as the sole determiner of safety.
@@ -273,6 +275,67 @@ The injected system prompt instructs the LLM to respond with empathy, validate f
 
 ---
 
+## Risk Trajectory & Time-Decay
+
+HumaneProxy tracks a **rolling window** of the last 5 risk scores per session.
+When a new message arrives, its score is compared against the
+**decay-weighted mean** of that window:
+
+```
+delta = current_score − weighted_mean(last N scores)
+spike = delta > 0.35    (configurable via spike_delta)
+```
+
+If a spike is detected, a **boost penalty** (`+0.25`) is added to the
+current score to push it closer to escalation.
+
+### Exponential Time-Decay
+
+Historical scores are weighted using the formula:
+
+$$w_i = e^{-\lambda \, \Delta t_i}$$
+
+where **λ = ln(2) / half-life** and **Δt** is the age of each score in
+seconds.  This means:
+
+| Time elapsed | Weight (24 h half-life) | Meaning |
+|---|---|---|
+| 5 minutes | 99.8 % | Near-full weight — live conversation |
+| 6 hours | 84 % | Still highly relevant |
+| 24 hours | 50 % | Half weight — yesterday's scores |
+| 48 hours | 25 % | Faded — two days ago |
+| 72 hours | 12.5 % | Nearly forgotten |
+
+**Why this matters:** Without decay, a user who had a tough conversation
+on Monday would carry that elevated baseline into Thursday—unfairly
+triggering spikes on innocuous messages.  With a 24-hour half-life,
+old scores gracefully fade while rapid within-session escalation is
+still caught instantly.
+
+### Configuration
+
+```yaml
+trajectory:
+  window_size: 5          # messages in rolling window
+  spike_delta: 0.35       # delta threshold for spike detection
+
+  # Half-life in hours.  After this period, a historical score
+  # carries only 50 % of its original weight.
+  #   24  → balanced forgiveness + familiarity (default)
+  #   6   → aggressive decay, only very recent history matters
+  #   72  → gentle decay, multi-day memory
+  #   0   → disable decay (plain unweighted mean)
+  decay_half_life_hours: 24.0
+```
+
+Or via environment variable:
+
+```bash
+export HUMANE_PROXY_DECAY_HALF_LIFE=12   # 12-hour half-life
+```
+
+---
+
 ## Alert Webhooks
 
 Configure in `humane_proxy.yaml`:

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/README.md

@@ -129,6 +129,8 @@ stage2:
   safe_threshold: 0.35         # cosine similarity below this → safe
 ```
 
+> **Multilingual Support:** If your users converse in non-English languages (Roman Hindi, Spanish, Arabic, etc.), change the `model` in your configuration to `"paraphrase-multilingual-MiniLM-L12-v2"`. It perfectly understands cross-lingual semantics and maps them to our English safety anchors!
+
 The model lazy-loads on first use. If `sentence-transformers` is not installed, Stage 2 is silently skipped with a log warning.
 
 > **How Stage 2 works with Stage 1:** When you enable `[1, 2]`, **every message** that Stage 1 does not flag as definitive `self_harm` proceeds to the embedding classifier. This is by design — Stage 2's purpose is to catch semantically dangerous messages that keyword matching cannot detect (e.g. *"Nobody would notice if I disappeared"*). Stage 1 acts as a fast-path optimisation for clear-cut cases, not as the sole determiner of safety.
@@ -216,6 +218,67 @@ The injected system prompt instructs the LLM to respond with empathy, validate f
 
 ---
 
+## Risk Trajectory & Time-Decay
+
+HumaneProxy tracks a **rolling window** of the last 5 risk scores per session.
+When a new message arrives, its score is compared against the
+**decay-weighted mean** of that window:
+
+```
+delta = current_score − weighted_mean(last N scores)
+spike = delta > 0.35    (configurable via spike_delta)
+```
+
+If a spike is detected, a **boost penalty** (`+0.25`) is added to the
+current score to push it closer to escalation.
+
+### Exponential Time-Decay
+
+Historical scores are weighted using the formula:
+
+$$w_i = e^{-\lambda \, \Delta t_i}$$
+
+where **λ = ln(2) / half-life** and **Δt** is the age of each score in
+seconds.  This means:
+
+| Time elapsed | Weight (24 h half-life) | Meaning |
+|---|---|---|
+| 5 minutes | 99.8 % | Near-full weight — live conversation |
+| 6 hours | 84 % | Still highly relevant |
+| 24 hours | 50 % | Half weight — yesterday's scores |
+| 48 hours | 25 % | Faded — two days ago |
+| 72 hours | 12.5 % | Nearly forgotten |
+
+**Why this matters:** Without decay, a user who had a tough conversation
+on Monday would carry that elevated baseline into Thursday—unfairly
+triggering spikes on innocuous messages.  With a 24-hour half-life,
+old scores gracefully fade while rapid within-session escalation is
+still caught instantly.
+
+### Configuration
+
+```yaml
+trajectory:
+  window_size: 5          # messages in rolling window
+  spike_delta: 0.35       # delta threshold for spike detection
+
+  # Half-life in hours.  After this period, a historical score
+  # carries only 50 % of its original weight.
+  #   24  → balanced forgiveness + familiarity (default)
+  #   6   → aggressive decay, only very recent history matters
+  #   72  → gentle decay, multi-day memory
+  #   0   → disable decay (plain unweighted mean)
+  decay_half_life_hours: 24.0
+```
+
+Or via environment variable:
+
+```bash
+export HUMANE_PROXY_DECAY_HALF_LIFE=12   # 12-hour half-life
+```
+
+---
+
 ## Alert Webhooks
 
 Configure in `humane_proxy.yaml`:

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/__init__.py

@@ -16,7 +16,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 # ---------------------------------------------------------------------------
 # Legacy API — keep backward compatibility with existing modules that call

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/cli.py

@@ -346,7 +346,7 @@ def mcp_serve(transport: str, host: str, port: int) -> None:
             serve_http(host=host, port=port)
         else:
             from humane_proxy.mcp_server import serve
-            click.echo("  🤖 Starting HumaneProxy MCP server (stdio)...")
+            click.echo("  🤖 Starting HumaneProxy MCP server (stdio)...", err=True)
             serve()
     except RuntimeError as exc:
         click.echo(f"\n  ❌ {exc}\n", err=True)

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/config.py

@@ -88,6 +88,7 @@ def _apply_env_overrides(config: dict) -> dict:
         "HUMANE_PROXY_STORAGE_BACKEND": (["storage", "backend"], str),
         "HUMANE_PROXY_REDIS_URL": (["storage", "redis", "url"], str),
         "HUMANE_PROXY_POSTGRES_DSN": (["storage", "postgres", "dsn"], str),
+        "HUMANE_PROXY_DECAY_HALF_LIFE": (["trajectory", "decay_half_life_hours"], float),
     }
 
     for env_key, (path, cast) in _ENV_MAP.items():

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/config.yaml

@@ -97,6 +97,18 @@ trajectory:
   # Delta threshold: if current_score - mean(last N) > spike_delta, flag it.
   spike_delta: 0.35
 
+  # Exponential time-decay half-life (hours).
+  # After this many hours, a historical score carries only 50 % of its
+  # original weight in the rolling baseline.  This prevents stale data
+  # from penalising returning users while still catching rapid escalation.
+  #
+  # Examples:
+  #   24  → a score from yesterday has 50 % weight (default)
+  #   6   → aggressive decay; only very recent history matters
+  #   72  → gentle decay; multi-day memory
+  #   0   → disable decay entirely (plain unweighted mean)
+  decay_half_life_hours: 24.0
+
 escalation:
   # Per-session rate limiting for escalation logging.
   rate_limit_max: 3

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/middleware/interceptor.py

@@ -51,7 +51,7 @@ async def _lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
 
 app = FastAPI(
     title="HumaneProxy",
-    version="0.3.0",
+    version="0.3.1",
     description="Lightweight AI safety middleware that protects humans.",
     lifespan=_lifespan,
 )

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/humane_proxy/risk/trajectory.py

@@ -1,9 +1,15 @@
-"""RiskTracker — trajectory-based spike detection and trend analysis."""
+"""RiskTracker — trajectory-based spike detection and trend analysis.
+
+Supports **exponential time-decay** so that stale scores from hours or
+days ago naturally fade toward zero, giving returning users a fair
+baseline while still catching rapid within-session escalation.
+"""
 
 from __future__ import annotations
 
+import math
+import time
 from collections import deque
-from statistics import mean
 
 from humane_proxy import load_config
 from humane_proxy.classifiers.models import TrajectoryResult
@@ -15,13 +21,26 @@ _CFG: dict = load_config().get("trajectory", {})
 _WINDOW_SIZE: int = _CFG.get("window_size", 5)
 _SPIKE_DELTA: float = _CFG.get("spike_delta", 0.35)
 
+# Decay half-life in hours.  After this many hours a historical score
+# contributes only 50 % of its original weight to the rolling baseline.
+# Set to 0 or negative to disable decay entirely.
+_DECAY_HALF_LIFE_HOURS: float = _CFG.get("decay_half_life_hours", 24.0)
+
+# Precompute lambda: λ = ln(2) / half_life.
+_DECAY_LAMBDA: float = (
+    math.log(2) / (_DECAY_HALF_LIFE_HOURS * 3600)
+    if _DECAY_HALF_LIFE_HOURS > 0
+    else 0.0
+)
+
 # Maximum distinct sessions to track before eviction (memory-leak prevention).
 _MAX_SESSIONS: int = 1000
 
 # ---------------------------------------------------------------------------
 # In-memory session stores
 # ---------------------------------------------------------------------------
-session_history: dict[str, deque[float]] = {}
+# Each entry is (score, timestamp_seconds).
+session_history: dict[str, deque[tuple[float, float]]] = {}
 _category_history: dict[str, deque[str]] = {}
 
 
@@ -38,12 +57,43 @@ def _evict_oldest_sessions() -> None:
         _category_history.pop(oldest_key, None)
 
 
+# ---------------------------------------------------------------------------
+# Decay-weighted mean
+# ---------------------------------------------------------------------------
+
+def _weighted_mean(history: deque[tuple[float, float]], now: float) -> float:
+    """Compute the exponentially time-decayed weighted mean of *history*.
+
+    Each entry ``(score, ts)`` is weighted by ``e^{-λ(now-ts)}``.
+    When decay is disabled (λ = 0), this collapses to a plain mean.
+
+    Returns 0.0 when *history* is empty (should never happen in practice
+    because callers gate on ``len(history) == 0`` first).
+    """
+    if _DECAY_LAMBDA == 0.0:
+        # Fast path: decay disabled — plain mean.
+        return sum(s for s, _ in history) / len(history) if history else 0.0
+
+    total_weight = 0.0
+    weighted_sum = 0.0
+    for score, ts in history:
+        dt = now - ts  # seconds elapsed
+        w = math.exp(-_DECAY_LAMBDA * dt)
+        weighted_sum += score * w
+        total_weight += w
+
+    return weighted_sum / total_weight if total_weight > 0 else 0.0
+
+
 def detect_spike(session_id: str, current_score: float) -> bool:
     """Return ``True`` if the current score spikes above the recent average.
 
     Math
     ----
-    ``delta = current_score - mean(last N scores)``
+    ``delta = current_score - weighted_mean(last N scores)``
+
+    Historical scores are weighted by ``e^{-λ Δt}`` (exponential
+    time-decay with a configurable half-life, default 24 h).
 
     If ``delta > _SPIKE_DELTA`` (default **0.35**), the interaction is
     considered a behavioural spike.
@@ -60,6 +110,8 @@ def detect_spike(session_id: str, current_score: float) -> bool:
     bool
         Whether a spike was detected.
     """
+    now = time.time()
+
     # --- memory-leak guard ---
     if len(session_history) > _MAX_SESSIONS and session_id not in session_history:
         _evict_oldest_sessions()
@@ -72,15 +124,15 @@ def detect_spike(session_id: str, current_score: float) -> bool:
 
     # Not enough history to calculate a meaningful delta yet.
     if len(history) == 0:
-        history.append(current_score)
+        history.append((current_score, now))
         return False
 
-    avg = mean(history)
+    avg = _weighted_mean(history, now)
     delta = current_score - avg
 
     # Always record *after* computing the delta so the current score
     # doesn't influence the baseline it's compared against.
-    history.append(current_score)
+    history.append((current_score, now))
 
     return delta > _SPIKE_DELTA
 
@@ -123,16 +175,16 @@ def analyze(
         _category_history[session_id] = deque(maxlen=_WINDOW_SIZE)
     _category_history[session_id].append(category)
 
-    # Get current window.
+    # Get current window (extract raw scores for the public API).
     history = session_history.get(session_id, deque())
-    scores = list(history)
+    scores = [s for s, _ in history]
 
     # Trend detection: compare first half vs second half of the window.
     trend = "stable"
     if len(scores) >= 4:
         mid = len(scores) // 2
-        first_half_avg = mean(scores[:mid])
-        second_half_avg = mean(scores[mid:])
+        first_half_avg = sum(scores[:mid]) / mid
+        second_half_avg = sum(scores[mid:]) / (len(scores) - mid)
         trend_delta = second_half_avg - first_half_avg
         if trend_delta > 0.15:
             trend = "escalating"

{humane_proxy-0.3.0 → humane_proxy-0.3.1/humane_proxy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: humane-proxy
-Version: 0.3.0
+Version: 0.3.1
 Summary: Lightweight, plug-and-play AI safety middleware that protects humans.
 Author-email: Vishisht Mishra <Vishisht16@users.noreply.github.com>
 License: Apache-2.0
@@ -186,6 +186,8 @@ stage2:
   safe_threshold: 0.35         # cosine similarity below this → safe
 ```
 
+> **Multilingual Support:** If your users converse in non-English languages (Roman Hindi, Spanish, Arabic, etc.), change the `model` in your configuration to `"paraphrase-multilingual-MiniLM-L12-v2"`. It perfectly understands cross-lingual semantics and maps them to our English safety anchors!
+
 The model lazy-loads on first use. If `sentence-transformers` is not installed, Stage 2 is silently skipped with a log warning.
 
 > **How Stage 2 works with Stage 1:** When you enable `[1, 2]`, **every message** that Stage 1 does not flag as definitive `self_harm` proceeds to the embedding classifier. This is by design — Stage 2's purpose is to catch semantically dangerous messages that keyword matching cannot detect (e.g. *"Nobody would notice if I disappeared"*). Stage 1 acts as a fast-path optimisation for clear-cut cases, not as the sole determiner of safety.
@@ -273,6 +275,67 @@ The injected system prompt instructs the LLM to respond with empathy, validate f
 
 ---
 
+## Risk Trajectory & Time-Decay
+
+HumaneProxy tracks a **rolling window** of the last 5 risk scores per session.
+When a new message arrives, its score is compared against the
+**decay-weighted mean** of that window:
+
+```
+delta = current_score − weighted_mean(last N scores)
+spike = delta > 0.35    (configurable via spike_delta)
+```
+
+If a spike is detected, a **boost penalty** (`+0.25`) is added to the
+current score to push it closer to escalation.
+
+### Exponential Time-Decay
+
+Historical scores are weighted using the formula:
+
+$$w_i = e^{-\lambda \, \Delta t_i}$$
+
+where **λ = ln(2) / half-life** and **Δt** is the age of each score in
+seconds.  This means:
+
+| Time elapsed | Weight (24 h half-life) | Meaning |
+|---|---|---|
+| 5 minutes | 99.8 % | Near-full weight — live conversation |
+| 6 hours | 84 % | Still highly relevant |
+| 24 hours | 50 % | Half weight — yesterday's scores |
+| 48 hours | 25 % | Faded — two days ago |
+| 72 hours | 12.5 % | Nearly forgotten |
+
+**Why this matters:** Without decay, a user who had a tough conversation
+on Monday would carry that elevated baseline into Thursday—unfairly
+triggering spikes on innocuous messages.  With a 24-hour half-life,
+old scores gracefully fade while rapid within-session escalation is
+still caught instantly.
+
+### Configuration
+
+```yaml
+trajectory:
+  window_size: 5          # messages in rolling window
+  spike_delta: 0.35       # delta threshold for spike detection
+
+  # Half-life in hours.  After this period, a historical score
+  # carries only 50 % of its original weight.
+  #   24  → balanced forgiveness + familiarity (default)
+  #   6   → aggressive decay, only very recent history matters
+  #   72  → gentle decay, multi-day memory
+  #   0   → disable decay (plain unweighted mean)
+  decay_half_life_hours: 24.0
+```
+
+Or via environment variable:
+
+```bash
+export HUMANE_PROXY_DECAY_HALF_LIFE=12   # 12-hour half-life
+```
+
+---
+
 ## Alert Webhooks
 
 Configure in `humane_proxy.yaml`:

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "humane-proxy"
-version = "0.3.0"
+version = "0.3.1"
 description = "Lightweight, plug-and-play AI safety middleware that protects humans."
 readme = "README.md"
 license = {text = "Apache-2.0"}

{humane_proxy-0.3.0 → humane_proxy-0.3.1}/server.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-09-29/server.schema.json",
   "name": "io.github.Vishisht16/humane-proxy",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "AI safety middleware — detects self-harm and criminal intent in LLM prompts.",
   "repository": {
     "url": "https://github.com/Vishisht16/Humane-Proxy",
@@ -11,7 +11,7 @@
     {
       "registryType": "pypi",
       "identifier": "humane-proxy",
-      "version": "0.3.0",
+      "version": "0.3.1",
       "packageArguments": [
         {
           "type": "positional",

humane_proxy-0.3.1/tests/test_trajectory.py

@@ -0,0 +1,180 @@
+"""Tests for humane_proxy.risk.trajectory (Phase 2 enhancements + time-decay)."""
+
+import math
+import time
+from collections import deque
+from unittest.mock import patch
+
+from humane_proxy.risk.trajectory import (
+    analyze,
+    detect_spike,
+    session_history,
+    _category_history,
+    _weighted_mean,
+)
+from humane_proxy.classifiers.models import TrajectoryResult
+
+
+class TestSpikeDetection:
+    def test_first_message_no_spike(self):
+        sid = "traj-first-v3"
+        assert detect_spike(sid, 0.0) is False
+
+    def test_stable_low_scores_no_spike(self):
+        sid = "traj-stable-v3"
+        for _ in range(5):
+            assert detect_spike(sid, 0.1) is False
+
+    def test_sudden_spike_detected(self):
+        sid = "traj-spike-v3"
+        for _ in range(3):
+            detect_spike(sid, 0.1)
+        assert detect_spike(sid, 0.9) is True
+
+    def test_gradual_increase_no_spike(self):
+        sid = "traj-gradual-v3"
+        for s in [0.1, 0.2, 0.3, 0.4, 0.5]:
+            result = detect_spike(sid, s)
+        assert result is False
+
+    def test_spike_after_zeros(self):
+        sid = "traj-zero-spike-v3"
+        for _ in range(5):
+            detect_spike(sid, 0.0)
+        assert detect_spike(sid, 0.5) is True
+
+
+class TestTimeDecay:
+    """Test exponential decay mechanics."""
+
+    def test_recent_scores_full_weight(self):
+        """Scores from seconds ago should be nearly full weight."""
+        now = time.time()
+        history = deque([
+            (0.5, now - 1),   # 1 second ago
+            (0.5, now - 2),   # 2 seconds ago
+        ])
+        avg = _weighted_mean(history, now)
+        # Should be very close to 0.5 (negligible decay within seconds).
+        assert abs(avg - 0.5) < 0.01
+
+    def test_old_scores_decay(self):
+        """Scores from 48 hours ago should carry ~25 % weight (two half-lives)."""
+        now = time.time()
+        two_days_ago = now - (48 * 3600)
+        history = deque([
+            (0.8, two_days_ago),  # old high score
+            (0.2, now - 1),       # recent low score
+        ])
+        avg = _weighted_mean(history, now)
+        # Old score decayed by ~75 %, recent at ~100 %.
+        # Weighted toward 0.2 rather than the plain mean of 0.5.
+        assert avg < 0.40
+
+    def test_decay_disabled_when_zero(self):
+        """When λ = 0, _weighted_mean collapses to plain mean."""
+        now = time.time()
+        long_ago = now - (7 * 24 * 3600)  # a week ago
+        history = deque([
+            (0.8, long_ago),
+            (0.2, now),
+        ])
+        with patch("humane_proxy.risk.trajectory._DECAY_LAMBDA", 0.0):
+            avg = _weighted_mean(history, now)
+        assert abs(avg - 0.5) < 0.01  # plain average of 0.8 and 0.2
+
+    def test_spike_after_long_absence(self):
+        """Returning after days with a moderate score should spike
+        because decayed history → near-zero baseline."""
+        sid = "traj-decay-spike"
+        now = time.time()
+        three_days = 3 * 24 * 3600
+        # Manually insert old history with timestamps from 3 days ago.
+        session_history[sid] = deque(maxlen=5)
+        session_history[sid].append((0.1, now - three_days))
+        session_history[sid].append((0.1, now - three_days + 1))
+        session_history[sid].append((0.1, now - three_days + 2))
+
+        # A moderate score of 0.5 should spike against the decayed baseline.
+        result = detect_spike(sid, 0.5)
+        assert result is True
+
+
+class TestAnalyze:
+    def test_returns_trajectory_result(self):
+        result = analyze("analyze-test-v3", 0.5, "safe")
+        assert isinstance(result, TrajectoryResult)
+
+    def test_first_message_stable(self):
+        result = analyze("analyze-first-v3", 0.1, "safe")
+        assert result.spike_detected is False
+        assert result.trend == "stable"
+        assert result.message_count == 1
+        assert result.category_counts == {"safe": 1}
+
+    def test_spike_detected(self):
+        sid = "analyze-spike-v3"
+        for _ in range(3):
+            analyze(sid, 0.1, "safe")
+        result = analyze(sid, 0.9, "self_harm")
+        assert result.spike_detected is True
+
+    def test_category_tracking(self):
+        sid = "analyze-cats-v3"
+        analyze(sid, 0.0, "safe")
+        analyze(sid, 0.0, "safe")
+        analyze(sid, 0.8, "self_harm")
+        result = analyze(sid, 0.0, "safe")
+        assert result.category_counts["safe"] == 3
+        assert result.category_counts["self_harm"] == 1
+
+    def test_window_scores_are_raw(self):
+        """window_scores should return raw floats, not tuples."""
+        sid = "analyze-raw-v3"
+        analyze(sid, 0.3, "safe")
+        result = analyze(sid, 0.7, "criminal_intent")
+        for s in result.window_scores:
+            assert isinstance(s, float)
+
+
+class TestTrendDetection:
+    def test_escalating_trend(self):
+        sid = "trend-escalate-v3"
+        for s in [0.1, 0.1, 0.5, 0.6]:
+            result = analyze(sid, s, "safe")
+        # first half avg: 0.1, second half avg: 0.55 → delta 0.45 > 0.15
+        assert result.trend == "escalating"
+
+    def test_declining_trend(self):
+        sid = "trend-decline-v3"
+        for s in [0.8, 0.7, 0.2, 0.1]:
+            result = analyze(sid, s, "safe")
+        # first half avg: 0.75, second half avg: 0.15 → delta -0.6 < -0.15
+        assert result.trend == "declining"
+
+    def test_stable_trend(self):
+        sid = "trend-stable-v3"
+        for s in [0.3, 0.35, 0.3, 0.35]:
+            result = analyze(sid, s, "safe")
+        assert result.trend == "stable"
+
+    def test_not_enough_for_trend(self):
+        sid = "trend-short-v3"
+        result = analyze(sid, 0.5, "safe")
+        assert result.trend == "stable"
+
+
+class TestMemoryEviction:
+    def test_session_cap(self):
+        for i in range(1001):
+            session_history[f"evict-test-v3-{i}"] = deque(
+                [(0.1, time.time())], maxlen=5
+            )
+
+        detect_spike("evict-new-v3", 0.5)
+        assert len(session_history) <= 1001
+
+    def test_eviction_preserves_new_sessions(self):
+        sid = "evict-survivor-v3"
+        detect_spike(sid, 0.3)
+        assert sid in session_history

humane_proxy-0.3.0/tests/test_trajectory.py

@@ -1,108 +0,0 @@
-"""Tests for humane_proxy.risk.trajectory (Phase 2 enhancements)."""
-
-from humane_proxy.risk.trajectory import (
-    analyze,
-    detect_spike,
-    session_history,
-    _category_history,
-)
-from humane_proxy.classifiers.models import TrajectoryResult
-
-
-class TestSpikeDetection:
-    def test_first_message_no_spike(self):
-        sid = "traj-first-v2"
-        assert detect_spike(sid, 0.0) is False
-
-    def test_stable_low_scores_no_spike(self):
-        sid = "traj-stable-v2"
-        for _ in range(5):
-            assert detect_spike(sid, 0.1) is False
-
-    def test_sudden_spike_detected(self):
-        sid = "traj-spike-v2"
-        for _ in range(3):
-            detect_spike(sid, 0.1)
-        assert detect_spike(sid, 0.9) is True
-
-    def test_gradual_increase_no_spike(self):
-        sid = "traj-gradual-v2"
-        for s in [0.1, 0.2, 0.3, 0.4, 0.5]:
-            result = detect_spike(sid, s)
-        assert result is False
-
-    def test_spike_after_zeros(self):
-        sid = "traj-zero-spike-v2"
-        for _ in range(5):
-            detect_spike(sid, 0.0)
-        assert detect_spike(sid, 0.5) is True
-
-
-class TestAnalyze:
-    def test_returns_trajectory_result(self):
-        result = analyze("analyze-test-1", 0.5, "safe")
-        assert isinstance(result, TrajectoryResult)
-
-    def test_first_message_stable(self):
-        result = analyze("analyze-first", 0.1, "safe")
-        assert result.spike_detected is False
-        assert result.trend == "stable"
-        assert result.message_count == 1
-        assert result.category_counts == {"safe": 1}
-
-    def test_spike_detected(self):
-        sid = "analyze-spike"
-        for _ in range(3):
-            analyze(sid, 0.1, "safe")
-        result = analyze(sid, 0.9, "self_harm")
-        assert result.spike_detected is True
-
-    def test_category_tracking(self):
-        sid = "analyze-cats"
-        analyze(sid, 0.0, "safe")
-        analyze(sid, 0.0, "safe")
-        analyze(sid, 0.8, "self_harm")
-        result = analyze(sid, 0.0, "safe")
-        assert result.category_counts["safe"] == 3
-        assert result.category_counts["self_harm"] == 1
-
-
-class TestTrendDetection:
-    def test_escalating_trend(self):
-        sid = "trend-escalate"
-        for s in [0.1, 0.1, 0.5, 0.6]:
-            result = analyze(sid, s, "safe")
-        # first half avg: 0.1, second half avg: 0.55 → delta 0.45 > 0.15
-        assert result.trend == "escalating"
-
-    def test_declining_trend(self):
-        sid = "trend-decline"
-        for s in [0.8, 0.7, 0.2, 0.1]:
-            result = analyze(sid, s, "safe")
-        # first half avg: 0.75, second half avg: 0.15 → delta -0.6 < -0.15
-        assert result.trend == "declining"
-
-    def test_stable_trend(self):
-        sid = "trend-stable"
-        for s in [0.3, 0.35, 0.3, 0.35]:
-            result = analyze(sid, s, "safe")
-        assert result.trend == "stable"
-
-    def test_not_enough_for_trend(self):
-        sid = "trend-short"
-        result = analyze(sid, 0.5, "safe")
-        assert result.trend == "stable"
-
-
-class TestMemoryEviction:
-    def test_session_cap(self):
-        for i in range(1001):
-            session_history[f"evict-test-v2-{i}"] = __import__("collections").deque([0.1], maxlen=5)
-
-        detect_spike("evict-new-v2", 0.5)
-        assert len(session_history) <= 1001
-
-    def test_eviction_preserves_new_sessions(self):
-        sid = "evict-survivor-v2"
-        detect_spike(sid, 0.3)
-        assert sid in session_history