superlocalmemory 2.7.6 → 2.8.1

package/src/behavioral/tests/test_cross_project_transfer.py

@@ -0,0 +1,142 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for privacy-safe cross-project behavioral transfer.
+"""
+import sqlite3
+import tempfile
+import os
+import sys
+import json
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestCrossProjectTransfer:
+    """Test cross-project behavioral pattern transfer."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "learning.db")
+        conn = sqlite3.connect(self.db_path)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS behavioral_patterns (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                pattern_type TEXT NOT NULL,
+                pattern_key TEXT NOT NULL,
+                success_rate REAL DEFAULT 0.0,
+                evidence_count INTEGER DEFAULT 0,
+                confidence REAL DEFAULT 0.0,
+                metadata TEXT DEFAULT '{}',
+                project TEXT,
+                profile TEXT DEFAULT 'default',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS cross_project_behaviors (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                source_project TEXT NOT NULL,
+                target_project TEXT NOT NULL,
+                pattern_id INTEGER NOT NULL,
+                transfer_type TEXT DEFAULT 'metadata',
+                confidence REAL DEFAULT 0.0,
+                profile TEXT DEFAULT 'default',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (pattern_id) REFERENCES behavioral_patterns(id)
+            )
+        """)
+        # Insert patterns: high-confidence pattern in project_a
+        conn.execute(
+            "INSERT INTO behavioral_patterns (pattern_type, pattern_key, success_rate, evidence_count, confidence, project) VALUES (?, ?, ?, ?, ?, ?)",
+            ("action_type_success", "code_written", 0.85, 12, 0.9, "project_a"),
+        )
+        # Low-confidence pattern (should NOT transfer)
+        conn.execute(
+            "INSERT INTO behavioral_patterns (pattern_type, pattern_key, success_rate, evidence_count, confidence, project) VALUES (?, ?, ?, ?, ?, ?)",
+            ("action_type_success", "debug_resolved", 0.4, 3, 0.2, "project_a"),
+        )
+        # High-confidence pattern for project_b
+        conn.execute(
+            "INSERT INTO behavioral_patterns (pattern_type, pattern_key, success_rate, evidence_count, confidence, project) VALUES (?, ?, ?, ?, ?, ?)",
+            ("project_success", "project_b", 0.9, 15, 0.95, "project_b"),
+        )
+        conn.commit()
+        conn.close()
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_evaluate_transfers(self):
+        """evaluate_transfers returns eligible patterns."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        eligible = transfer.evaluate_transfers(target_project="project_c")
+        assert isinstance(eligible, list)
+        assert len(eligible) >= 1  # At least the high-confidence pattern
+
+    def test_only_high_confidence_transfers(self):
+        """Only patterns with confidence >= 0.7 and evidence >= 5 transfer."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        eligible = transfer.evaluate_transfers(target_project="project_c")
+        for e in eligible:
+            assert e["confidence"] >= 0.7
+            assert e["evidence_count"] >= 5
+
+    def test_low_confidence_excluded(self):
+        """Low confidence patterns (id=2, confidence=0.2) should NOT transfer."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        eligible = transfer.evaluate_transfers(target_project="project_c")
+        pattern_ids = {e["pattern_id"] for e in eligible}
+        assert 2 not in pattern_ids  # Low confidence pattern excluded
+
+    def test_only_metadata_transfers(self):
+        """Transfers must be metadata-only — never content."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        eligible = transfer.evaluate_transfers(target_project="project_c")
+        for e in eligible:
+            assert e["transfer_type"] == "metadata"
+            assert "content" not in e  # No content field
+            assert "content_hash" not in e  # No content hashes
+
+    def test_apply_transfer(self):
+        """apply_transfer records the transfer in cross_project_behaviors."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        result = transfer.apply_transfer(pattern_id=1, target_project="project_c")
+        assert result["success"] is True
+        # Verify in DB
+        conn = sqlite3.connect(self.db_path)
+        row = conn.execute("SELECT * FROM cross_project_behaviors WHERE target_project='project_c'").fetchone()
+        conn.close()
+        assert row is not None
+
+    def test_transfer_logged(self):
+        """Transfers are logged with source and target projects."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        transfer.apply_transfer(pattern_id=1, target_project="project_c")
+        transfers = transfer.get_transfers(target_project="project_c")
+        assert len(transfers) == 1
+        assert transfers[0]["source_project"] == "project_a"
+
+    def test_no_self_transfer(self):
+        """Patterns should not transfer to their own project."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path)
+        eligible = transfer.evaluate_transfers(target_project="project_a")
+        # Pattern 1 is from project_a — should not be eligible for project_a
+        source_projects = {e.get("source_project") for e in eligible}
+        assert "project_a" not in source_projects
+
+    def test_disable_via_config(self):
+        """Transfers can be disabled via config."""
+        from behavioral.cross_project_transfer import CrossProjectTransfer
+        transfer = CrossProjectTransfer(self.db_path, enabled=False)
+        eligible = transfer.evaluate_transfers(target_project="project_c")
+        assert eligible == []

package/src/behavioral/tests/test_mcp_behavioral.py

@@ -0,0 +1,139 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for get_behavioral_patterns MCP tool handler.
+
+Validates the MCP wrapper around BehavioralPatternExtractor — tests
+pattern retrieval, confidence filtering, and project filtering.
+"""
+import asyncio
+import os
+import shutil
+import sqlite3
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+def _create_learning_db_with_patterns(db_path: str) -> None:
+    """Create learning.db with pre-seeded behavioral patterns."""
+    conn = sqlite3.connect(db_path)
+    # The BehavioralPatternExtractor creates this table itself, but we need
+    # pre-seeded data for read-only tests. Create it manually.
+    conn.execute(
+        """CREATE TABLE IF NOT EXISTS behavioral_patterns (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            pattern_type TEXT NOT NULL,
+            pattern_key TEXT NOT NULL,
+            success_rate REAL DEFAULT 0.0,
+            evidence_count INTEGER DEFAULT 0,
+            confidence REAL DEFAULT 0.0,
+            metadata TEXT DEFAULT '{}',
+            project TEXT,
+            profile TEXT DEFAULT 'default',
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )"""
+    )
+    # Pattern 1: high confidence, project-scoped
+    conn.execute(
+        "INSERT INTO behavioral_patterns "
+        "(pattern_type, pattern_key, success_rate, evidence_count, confidence, project) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        ("project_success", "slm-v28", 0.85, 12, 0.8, "slm-v28"),
+    )
+    # Pattern 2: low confidence, no project
+    conn.execute(
+        "INSERT INTO behavioral_patterns "
+        "(pattern_type, pattern_key, success_rate, evidence_count, confidence, project) "
+        "VALUES (?, ?, ?, ?, ?, ?)",
+        ("action_type_success", "code_written", 0.55, 4, 0.15, None),
+    )
+    conn.commit()
+    conn.close()
+
+
+class TestMCPBehavioralPatterns:
+    """Tests for the get_behavioral_patterns tool handler."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "learning.db")
+        _create_learning_db_with_patterns(self.db_path)
+
+    def teardown_method(self):
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def _run(self, coro):
+        return asyncio.get_event_loop().run_until_complete(coro)
+
+    def test_get_all_patterns(self):
+        """Without filters, should return all patterns."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns())
+        assert result["success"] is True
+        assert result["count"] == 2
+
+    def test_filter_by_high_confidence(self):
+        """Filtering with min_confidence=0.9 should return 0 (none that high)."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns(min_confidence=0.9))
+        assert result["success"] is True
+        assert result["count"] == 0
+
+    def test_filter_by_medium_confidence(self):
+        """Filtering with min_confidence=0.5 should return only the high-confidence one."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns(min_confidence=0.5))
+        assert result["success"] is True
+        assert result["count"] == 1
+        assert result["patterns"][0]["pattern_key"] == "slm-v28"
+
+    def test_filter_by_project(self):
+        """Filtering by project should scope results."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns(project="slm-v28"))
+        assert result["success"] is True
+        assert result["count"] == 1
+
+    def test_filter_by_nonexistent_project(self):
+        """Filtering by a project with no patterns should return 0."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns(project="nonexistent"))
+        assert result["success"] is True
+        assert result["count"] == 0
+
+    def test_patterns_have_required_keys(self):
+        """Each returned pattern should have standard keys."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.get_behavioral_patterns())
+        for pattern in result["patterns"]:
+            assert "pattern_type" in pattern
+            assert "pattern_key" in pattern
+            assert "success_rate" in pattern
+            assert "confidence" in pattern
+
+    def test_empty_db_returns_zero(self):
+        """An empty learning DB should return count=0."""
+        import mcp_tools_v28 as tools
+        empty_path = os.path.join(self.tmp_dir, "empty_learning.db")
+        tools.DEFAULT_LEARNING_DB = empty_path
+
+        result = self._run(tools.get_behavioral_patterns())
+        assert result["success"] is True
+        assert result["count"] == 0

package/src/behavioral/tests/test_mcp_report_outcome.py

@@ -0,0 +1,117 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for report_outcome MCP tool handler.
+
+Validates the MCP wrapper around OutcomeTracker — tests success/failure/partial
+outcomes, context handling, and invalid outcome rejection.
+"""
+import asyncio
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+# Ensure src/ is importable
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestMCPReportOutcome:
+    """Tests for the report_outcome tool handler."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "learning.db")
+
+    def teardown_method(self):
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def _run(self, coro):
+        """Helper to run async functions synchronously."""
+        return asyncio.get_event_loop().run_until_complete(coro)
+
+    def test_report_success_outcome(self):
+        """Reporting a 'success' outcome should return success=True and an outcome_id."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.report_outcome([1, 2], "success"))
+        assert result["success"] is True
+        assert isinstance(result["outcome_id"], int)
+        assert result["outcome_id"] > 0
+        assert result["outcome"] == "success"
+        assert result["memory_ids"] == [1, 2]
+
+    def test_report_failure_outcome(self):
+        """Reporting a 'failure' outcome should succeed."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.report_outcome([5], "failure"))
+        assert result["success"] is True
+        assert result["outcome"] == "failure"
+
+    def test_report_partial_outcome(self):
+        """Reporting a 'partial' outcome should succeed."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.report_outcome([3], "partial"))
+        assert result["success"] is True
+        assert result["outcome"] == "partial"
+
+    def test_report_invalid_outcome(self):
+        """An invalid outcome label should return success=False."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(tools.report_outcome([1], "invalid"))
+        assert result["success"] is False
+        assert "Invalid outcome" in result["error"]
+
+    def test_report_with_context_json(self):
+        """Context passed as JSON string should be accepted."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(
+            tools.report_outcome(
+                [1], "partial", context='{"note": "worked partially"}'
+            )
+        )
+        assert result["success"] is True
+
+    def test_report_with_action_type(self):
+        """Custom action_type should be accepted."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(
+            tools.report_outcome(
+                [1, 2, 3], "success", action_type="code_written"
+            )
+        )
+        assert result["success"] is True
+
+    def test_report_with_agent_and_project(self):
+        """agent_id and project parameters should be forwarded."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        result = self._run(
+            tools.report_outcome(
+                [1], "success", agent_id="agent_a", project="slm-v28"
+            )
+        )
+        assert result["success"] is True
+
+    def test_multiple_outcomes_unique_ids(self):
+        """Consecutive outcomes should get distinct IDs."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_LEARNING_DB = self.db_path
+
+        r1 = self._run(tools.report_outcome([1], "success"))
+        r2 = self._run(tools.report_outcome([2], "failure"))
+        assert r1["outcome_id"] != r2["outcome_id"]

package/src/behavioral/tests/test_outcome_inference.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for implicit outcome inference from recall behavior patterns.
+"""
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestOutcomeInference:
+    """Test inference rules for implicit outcome detection."""
+
+    def test_no_requery_implies_success(self):
+        """No re-query for 10+ min after recall -> success (0.6)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        # Record a recall event
+        engine.record_recall("query_abc", [1, 2], now - timedelta(minutes=12))
+        # Infer outcomes after enough time has passed
+        results = engine.infer_outcomes(now)
+        assert len(results) >= 1
+        result = results[0]
+        assert result["outcome"] == "success"
+        assert abs(result["confidence"] - 0.6) < 0.01
+
+    def test_memory_used_high_confirms_success(self):
+        """memory_used(high) within 5 min -> confirmed success (0.8)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("query_abc", [1], now - timedelta(minutes=3))
+        engine.record_usage("query_abc", signal="mcp_used_high", timestamp=now - timedelta(minutes=1))
+        results = engine.infer_outcomes(now)
+        success_results = [r for r in results if r["outcome"] == "success"]
+        assert len(success_results) >= 1
+        assert success_results[0]["confidence"] >= 0.8
+
+    def test_immediate_requery_implies_failure(self):
+        """Immediate re-query with different terms -> failure (0.2)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("query_abc", [1], now - timedelta(minutes=1))
+        engine.record_recall("different_query", [3], now - timedelta(seconds=30))
+        results = engine.infer_outcomes(now)
+        failure_results = [r for r in results if r["outcome"] == "failure"]
+        assert len(failure_results) >= 1
+        assert failure_results[0]["confidence"] <= 0.3
+
+    def test_memory_deleted_implies_failure(self):
+        """Memory deleted within 1 hour -> failure (0.0)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("query_abc", [1], now - timedelta(minutes=30))
+        engine.record_deletion(memory_id=1, timestamp=now - timedelta(minutes=5))
+        results = engine.infer_outcomes(now)
+        failure_results = [r for r in results if r["outcome"] == "failure" and 1 in r["memory_ids"]]
+        assert len(failure_results) >= 1
+        assert failure_results[0]["confidence"] <= 0.05
+
+    def test_rapid_fire_queries_implies_failure(self):
+        """3+ queries in 2 min -> failure (0.1)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("q1", [1], now - timedelta(seconds=90))
+        engine.record_recall("q2", [2], now - timedelta(seconds=60))
+        engine.record_recall("q3", [3], now - timedelta(seconds=30))
+        results = engine.infer_outcomes(now)
+        # At least some should be failure due to rapid-fire pattern
+        failure_results = [r for r in results if r["outcome"] == "failure"]
+        assert len(failure_results) >= 1
+
+    def test_cross_tool_access_implies_success(self):
+        """Cross-tool access after recall -> success (0.7)."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("query_abc", [1], now - timedelta(minutes=3))
+        engine.record_usage("query_abc", signal="implicit_positive_cross_tool", timestamp=now - timedelta(minutes=1))
+        results = engine.infer_outcomes(now)
+        success_results = [r for r in results if r["outcome"] == "success"]
+        assert len(success_results) >= 1
+        assert success_results[0]["confidence"] >= 0.7
+
+    def test_empty_buffer_returns_empty(self):
+        """No recorded events -> no inferences."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        results = engine.infer_outcomes(datetime.now())
+        assert results == []
+
+    def test_infer_clears_processed_events(self):
+        """After inference, processed events are cleared from buffer."""
+        from behavioral.outcome_inference import OutcomeInference
+        engine = OutcomeInference()
+        now = datetime.now()
+        engine.record_recall("q1", [1], now - timedelta(minutes=12))
+        results1 = engine.infer_outcomes(now)
+        assert len(results1) >= 1
+        # Second call should have nothing new
+        results2 = engine.infer_outcomes(now)
+        assert len(results2) == 0

package/src/behavioral/tests/test_outcome_tracker.py

@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for explicit action outcome recording.
+"""
+import sqlite3
+import tempfile
+import os
+import sys
+import json
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestOutcomeTracker:
+    """Test outcome recording and querying."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "learning.db")
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_record_success(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        oid = tracker.record_outcome([1, 2], "success", action_type="code_written")
+        assert isinstance(oid, int)
+        assert oid > 0
+
+    def test_record_failure(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        oid = tracker.record_outcome([3], "failure", context={"error": "timeout"})
+        assert oid > 0
+
+    def test_record_partial(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        oid = tracker.record_outcome([1], "partial", action_type="debug_resolved")
+        assert oid > 0
+
+    def test_confidence_for_explicit(self):
+        """Explicit outcomes should have confidence >= 0.8."""
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        tracker.record_outcome([1], "success")
+        outcomes = tracker.get_outcomes()
+        assert outcomes[0]["confidence"] >= 0.8
+
+    def test_multiple_memory_ids(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        tracker.record_outcome([1, 2, 3], "success")
+        outcomes = tracker.get_outcomes()
+        assert len(outcomes[0]["memory_ids"]) == 3
+
+    def test_get_outcomes_by_memory(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        tracker.record_outcome([1, 2], "success")
+        tracker.record_outcome([3], "failure")
+        results = tracker.get_outcomes(memory_id=1)
+        assert len(results) == 1
+
+    def test_get_outcomes_by_project(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        tracker.record_outcome([1], "success", project="proj_a")
+        tracker.record_outcome([2], "failure", project="proj_b")
+        results = tracker.get_outcomes(project="proj_a")
+        assert len(results) == 1
+
+    def test_get_success_rate(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        tracker.record_outcome([1], "success")
+        tracker.record_outcome([1], "success")
+        tracker.record_outcome([1], "failure")
+        rate = tracker.get_success_rate(1)
+        assert abs(rate - 0.667) < 0.01  # 2/3
+
+    def test_success_rate_no_outcomes(self):
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        rate = tracker.get_success_rate(999)
+        assert rate == 0.0
+
+    def test_valid_outcomes_only(self):
+        """Only success, failure, partial are valid outcomes."""
+        from behavioral.outcome_tracker import OutcomeTracker
+        tracker = OutcomeTracker(self.db_path)
+        result = tracker.record_outcome([1], "invalid_outcome")
+        assert result is None  # Rejected

package/src/cache_manager.py

@@ -1,16 +1,14 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Cache Manager
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - Cache Manager
 
-Copyright (c) 2026 Varun Pratap Bhardwaj
 Solution Architect & Original Creator
 
-Licensed under MIT License (see LICENSE file)
-Repository: https://github.com/varun369/SuperLocalMemoryV2
+ (see LICENSE file)
 
 ATTRIBUTION REQUIRED: This notice must be preserved in all copies.
 """
-
 """
 Cache Manager - LRU Cache for Search Results
 

package/src/compliance/__init__.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SLM v2.8 Compliance Engine — ABAC + Audit Trail + Retention.
+
+Enterprise-grade access control, tamper-evident audit trail,
+and retention policy management for GDPR/EU AI Act/HIPAA.
+
+Graceful degradation: if this module fails to import,
+all agents have full access (v2.7 behavior).
+"""
+import threading
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+COMPLIANCE_AVAILABLE = False
+_init_error = None
+
+try:
+    from .abac_engine import ABACEngine
+    from .audit_db import AuditDB
+    COMPLIANCE_AVAILABLE = True
+except ImportError as e:
+    _init_error = str(e)
+
+_abac_engine: Optional["ABACEngine"] = None
+_abac_lock = threading.Lock()
+
+
+def get_abac_engine(config_path: Optional[Path] = None) -> Optional["ABACEngine"]:
+    """Get or create the ABAC engine singleton."""
+    global _abac_engine
+    if not COMPLIANCE_AVAILABLE:
+        return None
+    with _abac_lock:
+        if _abac_engine is None:
+            try:
+                _abac_engine = ABACEngine(config_path)
+            except Exception:
+                return None
+        return _abac_engine
+
+
+def get_status() -> Dict[str, Any]:
+    return {
+        "compliance_available": COMPLIANCE_AVAILABLE,
+        "init_error": _init_error,
+        "abac_active": _abac_engine is not None,
+    }