superlocalmemory 2.7.6 → 2.8.0

package/src/learning/learning_db.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Learning Database Manager (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-Author: Varun Pratap Bhardwaj (Solution Architect)
-
-NOTICE: This software is protected by MIT License.
-Attribution must be preserved in all copies or derivatives.
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 """
 LearningDB — Manages the separate learning.db for behavioral data.
 
@@ -275,6 +265,63 @@ class LearningDB:
                 'ON engagement_metrics(metric_date)'
             )
 
+            # ------------------------------------------------------------------
+            # v2.8.0: Behavioral learning tables
+            # ------------------------------------------------------------------
+            cursor.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 1.0,
+                    agent_id TEXT DEFAULT 'user',
+                    project TEXT,
+                    profile TEXT DEFAULT 'default',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+
+            cursor.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
+                )
+            ''')
+
+            cursor.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)
+                )
+            ''')
+
+            # v2.8.0 indexes
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_outcomes_memory ON action_outcomes(memory_ids)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_outcomes_project ON action_outcomes(project)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_outcomes_profile ON action_outcomes(profile)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_bpatterns_type ON behavioral_patterns(pattern_type)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_bpatterns_project ON behavioral_patterns(project)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_xproject_source ON cross_project_behaviors(source_project)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_xproject_target ON cross_project_behaviors(target_project)')
+
             conn.commit()
             logger.info("Learning schema initialized successfully")
 
@@ -915,6 +962,127 @@ class LearningDB:
         finally:
             conn.close()
 
+    # ======================================================================
+    # v2.8.0: Action Outcomes CRUD
+    # ======================================================================
+
+    def store_outcome(self, memory_ids, outcome, action_type="other", context=None, confidence=1.0, agent_id="user", project=None, profile="default"):
+        """Store an action outcome for behavioral learning."""
+        memory_ids_str = json.dumps(memory_ids if isinstance(memory_ids, list) else [memory_ids])
+        context_str = json.dumps(context or {})
+        conn = self._get_connection()
+        try:
+            with self._write_lock:
+                cursor = conn.execute(
+                    "INSERT INTO action_outcomes (memory_ids, outcome, action_type, context, confidence, agent_id, project, profile) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    (memory_ids_str, outcome, action_type, context_str, confidence, agent_id, project, profile),
+                )
+                conn.commit()
+                return cursor.lastrowid
+        finally:
+            conn.close()
+
+    def get_outcomes(self, memory_id=None, project=None, profile="default", limit=100):
+        """Get action outcomes, optionally filtered."""
+        conn = self._get_connection()
+        try:
+            query = "SELECT * FROM action_outcomes WHERE profile = ?"
+            params = [profile]
+            if project:
+                query += " AND project = ?"
+                params.append(project)
+            query += " ORDER BY created_at DESC LIMIT ?"
+            params.append(limit)
+            rows = conn.execute(query, params).fetchall()
+            results = []
+            for row in rows:
+                d = dict(row)
+                d["memory_ids"] = json.loads(d["memory_ids"])
+                d["context"] = json.loads(d["context"])
+                if memory_id and memory_id not in d["memory_ids"]:
+                    continue
+                results.append(d)
+            return results
+        finally:
+            conn.close()
+
+    # ======================================================================
+    # v2.8.0: Behavioral Patterns CRUD
+    # ======================================================================
+
+    def store_behavioral_pattern(self, pattern_type, pattern_key, success_rate=0.0, evidence_count=0, confidence=0.0, metadata=None, project=None, profile="default"):
+        """Store or update a behavioral pattern."""
+        metadata_str = json.dumps(metadata or {})
+        conn = self._get_connection()
+        try:
+            with self._write_lock:
+                cursor = conn.execute(
+                    "INSERT INTO behavioral_patterns (pattern_type, pattern_key, success_rate, evidence_count, confidence, metadata, project, profile) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    (pattern_type, pattern_key, success_rate, evidence_count, confidence, metadata_str, project, profile),
+                )
+                conn.commit()
+                return cursor.lastrowid
+        finally:
+            conn.close()
+
+    def get_behavioral_patterns(self, pattern_type=None, project=None, min_confidence=0.0, profile="default"):
+        """Get behavioral patterns, optionally filtered."""
+        conn = self._get_connection()
+        try:
+            query = "SELECT * FROM behavioral_patterns WHERE profile = ? AND confidence >= ?"
+            params = [profile, min_confidence]
+            if pattern_type:
+                query += " AND pattern_type = ?"
+                params.append(pattern_type)
+            if project:
+                query += " AND project = ?"
+                params.append(project)
+            query += " ORDER BY confidence DESC"
+            rows = conn.execute(query, params).fetchall()
+            results = []
+            for row in rows:
+                d = dict(row)
+                d["metadata"] = json.loads(d["metadata"])
+                results.append(d)
+            return results
+        finally:
+            conn.close()
+
+    # ======================================================================
+    # v2.8.0: Cross-Project CRUD
+    # ======================================================================
+
+    def store_cross_project(self, source_project, target_project, pattern_id, transfer_type="metadata", confidence=0.0, profile="default"):
+        """Record a cross-project behavioral transfer."""
+        conn = self._get_connection()
+        try:
+            with self._write_lock:
+                cursor = conn.execute(
+                    "INSERT INTO cross_project_behaviors (source_project, target_project, pattern_id, transfer_type, confidence, profile) VALUES (?, ?, ?, ?, ?, ?)",
+                    (source_project, target_project, pattern_id, transfer_type, confidence, profile),
+                )
+                conn.commit()
+                return cursor.lastrowid
+        finally:
+            conn.close()
+
+    def get_cross_project_transfers(self, source_project=None, target_project=None, profile="default"):
+        """Get cross-project transfer records."""
+        conn = self._get_connection()
+        try:
+            query = "SELECT * FROM cross_project_behaviors WHERE profile = ?"
+            params = [profile]
+            if source_project:
+                query += " AND source_project = ?"
+                params.append(source_project)
+            if target_project:
+                query += " AND target_project = ?"
+                params.append(target_project)
+            query += " ORDER BY created_at DESC"
+            return [dict(row) for row in conn.execute(query, params).fetchall()]
+        finally:
+            conn.close()
+
     # ======================================================================
     # Reset / Cleanup
     # ======================================================================

package/src/learning/project_context_manager.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Project Context Manager (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-Author: Varun Pratap Bhardwaj (Solution Architect)
-
-NOTICE: This software is protected by MIT License.
-Attribution must be preserved in all copies or derivatives.
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 """
 ProjectContextManager — Layer 2: Multi-signal project detection.
 

package/src/learning/source_quality_scorer.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Source Quality Scorer (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-Author: Varun Pratap Bhardwaj (Solution Architect)
-
-NOTICE: This software is protected by MIT License.
-Attribution must be preserved in all copies or derivatives.
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 """
 SourceQualityScorer — Per-source quality learning.
 

package/src/learning/synthetic_bootstrap.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Synthetic Bootstrap (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-
-Repository: https://github.com/varun369/SuperLocalMemoryV2
-Author: Varun Pratap Bhardwaj (Solution Architect)
-
-NOTICE: This software is protected by MIT License.
-Attribution must be preserved in all copies or derivatives.
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 """
 SyntheticBootstrapper — Bootstrap ML model from existing data patterns.
 

package/src/learning/tests/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)

package/src/learning/tests/test_adaptive_ranker.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for AdaptiveRanker (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 import pytest
 
 

package/src/learning/tests/test_adaptive_ranker_v28.py

@@ -0,0 +1,60 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for v2.8 adaptive ranker — 20 features + lifecycle/behavioral boosts.
+"""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestAdaptiveRankerV28:
+    def test_num_features_is_20(self):
+        from learning.feature_extractor import NUM_FEATURES
+        assert NUM_FEATURES == 20
+
+    def test_new_rule_boosts_exist(self):
+        from learning.adaptive_ranker import _RULE_BOOST
+        assert 'lifecycle_active' in _RULE_BOOST
+        assert 'outcome_success_high' in _RULE_BOOST
+        assert 'behavioral_match_strong' in _RULE_BOOST
+        assert 'cross_project_boost' in _RULE_BOOST
+
+    def test_lifecycle_active_boost(self):
+        from learning.adaptive_ranker import _RULE_BOOST
+        assert _RULE_BOOST['lifecycle_active'] == 1.0
+        assert _RULE_BOOST['lifecycle_warm'] == 0.85
+        assert _RULE_BOOST['lifecycle_cold'] == 0.6
+
+    def test_outcome_boosts(self):
+        from learning.adaptive_ranker import _RULE_BOOST
+        assert _RULE_BOOST['outcome_success_high'] == 1.3
+        assert _RULE_BOOST['outcome_failure_high'] == 0.7
+
+    def test_phase1_works_with_20_features(self):
+        """Phase 1 (rule-based) ranking should work with 20-feature vectors."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+        results = [
+            {'id': 1, 'content': 'Python memory', 'score': 0.8, 'match_type': 'semantic',
+             'importance': 7, 'lifecycle_state': 'active'},
+            {'id': 2, 'content': 'Old memory', 'score': 0.7, 'match_type': 'semantic',
+             'importance': 3, 'lifecycle_state': 'cold'},
+        ]
+        ranked = ranker.rerank(results, "Python")
+        assert len(ranked) == 2
+        assert all('score' in r for r in ranked)
+
+    def test_active_memory_ranks_higher_than_cold(self):
+        """Active memories should score higher than cold with same base score."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+        results = [
+            {'id': 1, 'content': 'same content', 'score': 0.8, 'match_type': 'semantic',
+             'importance': 5, 'lifecycle_state': 'cold'},
+            {'id': 2, 'content': 'same content', 'score': 0.8, 'match_type': 'semantic',
+             'importance': 5, 'lifecycle_state': 'active'},
+        ]
+        ranked = ranker.rerank(results, "test")
+        # Active (id=2) should rank higher than cold (id=1)
+        if len(ranked) >= 2:
+            assert ranked[0]['id'] == 2 or ranked[0]['score'] >= ranked[1]['score']

package/src/learning/tests/test_aggregator.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for CrossProjectAggregator (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 import math
 import sqlite3
 from datetime import datetime, timedelta

package/src/learning/tests/test_auto_retrain_v28.py

@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for auto-retrain mechanism when feature dimensions change 12->20.
+"""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestAutoRetrain:
+    def test_feature_dimension_is_20(self):
+        from learning.feature_extractor import NUM_FEATURES
+        assert NUM_FEATURES == 20
+
+    def test_ranker_handles_dimension_mismatch(self):
+        """Ranker should not crash when loaded model has different dimensions."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+        # Even without a trained model, phase 1 should work
+        results = [{'id': 1, 'content': 'test', 'score': 0.5, 'match_type': 'semantic', 'importance': 5}]
+        ranked = ranker.rerank(results, "test")
+        assert len(ranked) == 1
+
+    def test_phase1_immediate_during_retrain(self):
+        """Phase 1 (rule-based) should work immediately even during model retrain."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+        results = [
+            {'id': 1, 'content': 'memory A', 'score': 0.9, 'match_type': 'semantic', 'importance': 8},
+            {'id': 2, 'content': 'memory B', 'score': 0.3, 'match_type': 'keyword', 'importance': 2},
+        ]
+        ranked = ranker.rerank(results, "test query")
+        assert len(ranked) == 2
+        # Higher base score should still rank first in phase 1
+        assert ranked[0]['score'] >= ranked[1]['score']

package/src/learning/tests/test_e2e_ranking_v28.py

@@ -0,0 +1,82 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""End-to-end tests for adaptive ranking with 20-feature vector.
+"""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestE2ERankingV28:
+    def test_full_20_feature_pipeline(self):
+        """Full pipeline: extract 20 features -> rank results."""
+        from learning.feature_extractor import FeatureExtractor
+        from learning.adaptive_ranker import AdaptiveRanker
+
+        extractor = FeatureExtractor()
+        ranker = AdaptiveRanker()
+
+        memories = [
+            {'id': 1, 'content': 'Python best practices for production', 'score': 0.8,
+             'match_type': 'semantic', 'importance': 8, 'lifecycle_state': 'active',
+             'access_count': 15, 'created_at': '2026-02-01'},
+            {'id': 2, 'content': 'Old JavaScript patterns deprecated', 'score': 0.75,
+             'match_type': 'semantic', 'importance': 3, 'lifecycle_state': 'cold',
+             'access_count': 1, 'created_at': '2025-06-01'},
+        ]
+
+        # Extract features
+        for mem in memories:
+            features = extractor.extract_features(mem, "Python production")
+            assert len(features) == 20
+
+        # Rank
+        ranked = ranker.rerank(memories, "Python production")
+        assert len(ranked) == 2
+
+    def test_lifecycle_affects_ranking(self):
+        """Active memories should generally rank above cold ones."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+
+        results = [
+            {'id': 1, 'content': 'cold memory', 'score': 0.85, 'match_type': 'semantic',
+             'importance': 5, 'lifecycle_state': 'cold'},
+            {'id': 2, 'content': 'active memory', 'score': 0.80, 'match_type': 'semantic',
+             'importance': 5, 'lifecycle_state': 'active'},
+        ]
+        ranked = ranker.rerank(results, "test")
+        # Even with slightly lower base score, active should win due to lifecycle boost
+        assert ranked[0]['id'] == 2
+
+    def test_high_outcome_success_boosts_ranking(self):
+        """Memories with high success rates should rank higher."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+
+        results = [
+            {'id': 1, 'content': 'frequently failing', 'score': 0.8, 'match_type': 'semantic',
+             'importance': 5, 'outcome_success_rate': 0.1},
+            {'id': 2, 'content': 'consistently useful', 'score': 0.8, 'match_type': 'semantic',
+             'importance': 5, 'outcome_success_rate': 0.95},
+        ]
+        ranked = ranker.rerank(results, "test")
+        assert ranked[0]['id'] == 2
+
+    def test_result_ordering_reflects_all_signals(self):
+        """Result ordering should reflect lifecycle + behavioral + base score."""
+        from learning.adaptive_ranker import AdaptiveRanker
+        ranker = AdaptiveRanker()
+
+        results = [
+            {'id': 1, 'content': 'A', 'score': 0.7, 'match_type': 'semantic', 'importance': 5,
+             'lifecycle_state': 'active', 'outcome_success_rate': 0.9},
+            {'id': 2, 'content': 'B', 'score': 0.9, 'match_type': 'semantic', 'importance': 5,
+             'lifecycle_state': 'cold', 'outcome_success_rate': 0.1},
+            {'id': 3, 'content': 'C', 'score': 0.8, 'match_type': 'semantic', 'importance': 8,
+             'lifecycle_state': 'active', 'outcome_success_rate': 0.5},
+        ]
+        ranked = ranker.rerank(results, "test")
+        assert len(ranked) == 3
+        # All should have final scores
+        assert all('score' in r for r in ranked)

package/src/learning/tests/test_feature_extractor_v28.py

@@ -0,0 +1,93 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for v2.8 feature extractor — 20-dimensional feature vectors.
+"""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestFeatureExtractorV28:
+    def test_feature_count_is_20(self):
+        from learning.feature_extractor import FEATURE_NAMES
+        assert len(FEATURE_NAMES) == 20
+
+    def test_new_feature_names_present(self):
+        from learning.feature_extractor import FEATURE_NAMES
+        new_features = ['lifecycle_state', 'outcome_success_rate', 'outcome_count',
+                       'behavioral_match', 'cross_project_score', 'retention_priority',
+                       'trust_at_creation', 'lifecycle_aware_decay']
+        for f in new_features:
+            assert f in FEATURE_NAMES
+
+    def test_extract_returns_20_features(self):
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        memory = {
+            'id': 1, 'content': 'test memory about Python', 'importance': 5,
+            'created_at': '2026-02-20T10:00:00', 'last_accessed': '2026-02-25T10:00:00',
+            'access_count': 3, 'tags': ['python'], 'project_name': 'myproject',
+            'lifecycle_state': 'active', 'score': 0.8, 'match_type': 'semantic',
+        }
+        features = extractor.extract_features(memory, "Python programming")
+        assert len(features) == 20
+        assert all(isinstance(f, (int, float)) for f in features)
+
+    def test_lifecycle_state_encoding(self):
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        base = {'id': 1, 'content': 'test', 'importance': 5, 'created_at': '2026-02-20',
+                'access_count': 0, 'score': 0.5, 'match_type': 'semantic'}
+
+        active = extractor.extract_features({**base, 'lifecycle_state': 'active'}, "test")
+        warm = extractor.extract_features({**base, 'lifecycle_state': 'warm'}, "test")
+        cold = extractor.extract_features({**base, 'lifecycle_state': 'cold'}, "test")
+
+        assert active[12] > warm[12] > cold[12]
+
+    def test_default_values_when_data_missing(self):
+        """Features should return sensible defaults when data is unavailable."""
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        minimal = {'id': 1, 'content': 'test', 'importance': 5, 'score': 0.5, 'match_type': 'semantic'}
+        features = extractor.extract_features(minimal, "test")
+        assert len(features) == 20
+        # lifecycle_state default (active) = 1.0
+        assert features[12] == 1.0
+        # outcome_success_rate default = 0.5
+        assert features[13] == 0.5
+        # retention_priority default = 0.5
+        assert features[17] == 0.5
+        # trust_at_creation default = 0.8
+        assert features[18] == 0.8
+
+    def test_backward_compat_old_12_features_still_work(self):
+        """The first 12 features should still be computed correctly."""
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        memory = {'id': 1, 'content': 'Python is great', 'importance': 8,
+                  'created_at': '2026-02-20', 'access_count': 5, 'score': 0.9,
+                  'match_type': 'semantic', 'lifecycle_state': 'active'}
+        features = extractor.extract_features(memory, "Python")
+        # importance_norm (index 6) should be 0.8 (8/10)
+        assert abs(features[6] - 0.8) < 0.01
+
+    def test_extract_batch_returns_20_wide(self):
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        memories = [
+            {'id': 1, 'content': 'mem1', 'importance': 5, 'score': 0.5, 'match_type': 'semantic'},
+            {'id': 2, 'content': 'mem2', 'importance': 7, 'score': 0.7, 'match_type': 'semantic'},
+        ]
+        batch = extractor.extract_batch(memories, "test")
+        assert len(batch) == 2
+        assert all(len(v) == 20 for v in batch)
+
+    def test_outcome_success_rate_from_memory(self):
+        """If memory has outcome_success_rate in dict, use it."""
+        from learning.feature_extractor import FeatureExtractor
+        extractor = FeatureExtractor()
+        memory = {'id': 1, 'content': 'test', 'importance': 5, 'score': 0.5,
+                  'match_type': 'semantic', 'outcome_success_rate': 0.85}
+        features = extractor.extract_features(memory, "test")
+        assert abs(features[13] - 0.85) < 0.01

package/src/learning/tests/test_feedback_collector.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for FeedbackCollector (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 import hashlib
 import time
 

package/src/learning/tests/test_learning_db.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for LearningDB (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 import json
 import sqlite3
 import threading