superlocalmemory 2.8.6 → 3.0.0

package/src/behavioral/tests/test_cross_project_transfer.py

@@ -1,142 +0,0 @@
-# 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

@@ -1,139 +0,0 @@
-# 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

@@ -1,117 +0,0 @@
-# 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

@@ -1,107 +0,0 @@
-# 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

@@ -1,96 +0,0 @@
-# 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