superlocalmemory 2.7.6 → 2.8.0

package/src/behavioral/tests/test_behavioral_integration.py

@@ -0,0 +1,108 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for behavioral engine EventBus integration.
+"""
+import sqlite3
+import tempfile
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestBehavioralIntegration:
+    """Test behavioral engine wiring with EventBus."""
+
+    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_create_behavioral_listener(self):
+        """BehavioralListener can be instantiated."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        assert listener is not None
+
+    def test_listener_handles_recall_event(self):
+        """Listener processes memory.recalled events."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        event = {
+            "event_type": "memory.recalled",
+            "memory_id": 1,
+            "payload": {"query": "test query", "memory_ids": [1, 2]},
+            "timestamp": datetime.now().isoformat(),
+        }
+        # Should not raise
+        listener.handle_event(event)
+        assert listener.events_processed >= 1
+
+    def test_listener_ignores_irrelevant_events(self):
+        """Listener ignores non-recall events."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        event = {
+            "event_type": "memory.created",
+            "memory_id": 1,
+            "payload": {},
+            "timestamp": datetime.now().isoformat(),
+        }
+        listener.handle_event(event)
+        assert listener.recall_events_processed == 0
+
+    def test_listener_handles_deletion_event(self):
+        """Listener records deletion events for inference."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        event = {
+            "event_type": "memory.deleted",
+            "memory_id": 5,
+            "payload": {},
+            "timestamp": datetime.now().isoformat(),
+        }
+        listener.handle_event(event)
+        assert listener.deletion_events_processed >= 1
+
+    def test_listener_tracks_usage_signals(self):
+        """Listener records usage signals (memory_used) for inference."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        event = {
+            "event_type": "memory.recalled",
+            "memory_id": 1,
+            "payload": {"query": "test", "memory_ids": [1], "signal": "mcp_used_high"},
+            "timestamp": datetime.now().isoformat(),
+        }
+        listener.handle_event(event)
+        assert listener.events_processed >= 1
+
+    def test_graceful_degradation_no_eventbus(self):
+        """If EventBus unavailable, behavioral engine still works."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        # register_with_eventbus should not crash even if EventBus fails
+        result = listener.register_with_eventbus()
+        # Result depends on whether EventBus is importable in test env
+        assert isinstance(result, bool)
+
+    def test_pattern_extraction_threshold(self):
+        """Pattern extraction triggers after outcome count threshold."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path, extraction_threshold=5)
+        assert listener.extraction_threshold == 5
+
+    def test_get_status(self):
+        """Listener reports its status."""
+        from behavioral.behavioral_listener import BehavioralListener
+        listener = BehavioralListener(self.db_path)
+        status = listener.get_status()
+        assert "events_processed" in status
+        assert "recall_events_processed" in status
+        assert "registered" in status

package/src/behavioral/tests/test_behavioral_patterns.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for behavioral pattern extraction from outcomes.
+"""
+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 TestBehavioralPatterns:
+    """Test pattern extraction from action outcomes."""
+
+    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)
+        # Create action_outcomes table (populated by OutcomeTracker)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS action_outcomes (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                memory_ids TEXT NOT NULL,
+                outcome TEXT NOT NULL,
+                action_type TEXT DEFAULT 'other',
+                context TEXT DEFAULT '{}',
+                confidence REAL DEFAULT 0.9,
+                agent_id TEXT DEFAULT 'user',
+                project TEXT,
+                profile TEXT DEFAULT 'default',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        # Create behavioral_patterns table
+        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
+            )
+        """)
+        # Insert sample outcomes for pattern extraction
+        # Project A: 8 success, 2 failure -> 80% success
+        for i in range(8):
+            conn.execute("INSERT INTO action_outcomes (memory_ids, outcome, project, action_type) VALUES (?, ?, ?, ?)",
+                (json.dumps([i+1]), "success", "project_a", "code_written"))
+        for i in range(2):
+            conn.execute("INSERT INTO action_outcomes (memory_ids, outcome, project, action_type) VALUES (?, ?, ?, ?)",
+                (json.dumps([i+20]), "failure", "project_a", "code_written"))
+        # Project B: 2 success, 8 failure -> 20% success
+        for i in range(2):
+            conn.execute("INSERT INTO action_outcomes (memory_ids, outcome, project, action_type) VALUES (?, ?, ?, ?)",
+                (json.dumps([i+30]), "success", "project_b", "debug_resolved"))
+        for i in range(8):
+            conn.execute("INSERT INTO action_outcomes (memory_ids, outcome, project, action_type) VALUES (?, ?, ?, ?)",
+                (json.dumps([i+40]), "failure", "project_b", "debug_resolved"))
+        conn.commit()
+        conn.close()
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_extract_patterns(self):
+        """extract_patterns returns list of discovered patterns."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        assert isinstance(patterns, list)
+        assert len(patterns) >= 2  # At least project_a and project_b patterns
+
+    def test_project_success_rate(self):
+        """Patterns should reflect actual success rates per project."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        proj_a = [p for p in patterns if p["pattern_key"] == "project_a" and p["pattern_type"] == "project_success"]
+        assert len(proj_a) == 1
+        assert abs(proj_a[0]["success_rate"] - 0.8) < 0.01
+
+    def test_success_pattern_high_rate(self):
+        """Projects with >70% success and 5+ evidence -> success pattern."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        proj_a = [p for p in patterns if p["pattern_key"] == "project_a" and p["pattern_type"] == "project_success"]
+        assert proj_a[0]["success_rate"] > 0.7
+        assert proj_a[0]["evidence_count"] >= 5
+
+    def test_failure_pattern_low_rate(self):
+        """Projects with <30% success and 5+ evidence -> failure pattern."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        proj_b = [p for p in patterns if p["pattern_key"] == "project_b" and p["pattern_type"] == "project_success"]
+        assert proj_b[0]["success_rate"] < 0.3
+
+    def test_action_type_patterns(self):
+        """Should extract patterns grouped by action_type."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        action_patterns = [p for p in patterns if p["pattern_type"] == "action_type_success"]
+        assert len(action_patterns) >= 1
+
+    def test_get_patterns_with_min_confidence(self):
+        """get_patterns filters by minimum confidence."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        extractor.extract_patterns()
+        # Store patterns to DB first
+        extractor.save_patterns()
+        high_conf = extractor.get_patterns(min_confidence=0.5)
+        all_patterns = extractor.get_patterns(min_confidence=0.0)
+        assert len(high_conf) <= len(all_patterns)
+
+    def test_pattern_confidence_scoring(self):
+        """Patterns with more evidence should have higher confidence."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        patterns = extractor.extract_patterns()
+        for p in patterns:
+            assert 0.0 <= p["confidence"] <= 1.0
+            # Confidence should increase with evidence
+            if p["evidence_count"] >= 10:
+                assert p["confidence"] >= 0.5
+
+    def test_save_patterns_to_db(self):
+        """save_patterns stores extracted patterns in behavioral_patterns table."""
+        from behavioral.behavioral_patterns import BehavioralPatternExtractor
+        extractor = BehavioralPatternExtractor(self.db_path)
+        extractor.extract_patterns()
+        count = extractor.save_patterns()
+        assert count >= 2
+        # Verify in DB
+        conn = sqlite3.connect(self.db_path)
+        rows = conn.execute("SELECT COUNT(*) FROM behavioral_patterns").fetchone()
+        conn.close()
+        assert rows[0] >= 2

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"]