superlocalmemory 2.7.6 → 2.8.0

package/src/learning/tests/test_learning_db_v28.py

@@ -0,0 +1,110 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for v2.8 learning.db schema extensions — outcome and behavioral tables.
+"""
+import pytest
+import json
+import sys
+import os
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+@pytest.fixture(autouse=True)
+def reset_singleton():
+    from learning.learning_db import LearningDB
+    LearningDB.reset_instance()
+    yield
+    LearningDB.reset_instance()
+
+
+@pytest.fixture
+def learning_db(tmp_path):
+    from learning.learning_db import LearningDB
+    db_path = tmp_path / "learning.db"
+    return LearningDB(db_path=db_path)
+
+
+class TestActionOutcomesTable:
+    def test_table_exists(self, learning_db):
+        conn = learning_db._get_connection()
+        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
+        conn.close()
+        assert "action_outcomes" in tables
+
+    def test_store_outcome(self, learning_db):
+        oid = learning_db.store_outcome([1, 2], "success", action_type="code_written", project="myproject")
+        assert isinstance(oid, int)
+        assert oid > 0
+
+    def test_get_outcomes(self, learning_db):
+        learning_db.store_outcome([1], "success", project="proj1")
+        learning_db.store_outcome([2], "failure", project="proj1")
+        results = learning_db.get_outcomes(project="proj1")
+        assert len(results) == 2
+
+    def test_get_outcomes_by_memory_id(self, learning_db):
+        learning_db.store_outcome([1, 2], "success")
+        learning_db.store_outcome([3], "failure")
+        results = learning_db.get_outcomes(memory_id=1)
+        assert len(results) == 1
+        assert 1 in results[0]["memory_ids"]
+
+    def test_outcome_has_profile(self, learning_db):
+        learning_db.store_outcome([1], "success")
+        results = learning_db.get_outcomes()
+        assert results[0]["profile"] == "default"
+
+
+class TestBehavioralPatternsTable:
+    def test_table_exists(self, learning_db):
+        conn = learning_db._get_connection()
+        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
+        conn.close()
+        assert "behavioral_patterns" in tables
+
+    def test_store_pattern(self, learning_db):
+        pid = learning_db.store_behavioral_pattern("tag_success", "python", success_rate=0.85, evidence_count=10, confidence=0.8)
+        assert isinstance(pid, int)
+
+    def test_get_patterns(self, learning_db):
+        learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
+        learning_db.store_behavioral_pattern("tag_success", "javascript", confidence=0.6)
+        results = learning_db.get_behavioral_patterns(pattern_type="tag_success")
+        assert len(results) == 2
+
+    def test_get_patterns_min_confidence(self, learning_db):
+        learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
+        learning_db.store_behavioral_pattern("tag_success", "javascript", confidence=0.3)
+        results = learning_db.get_behavioral_patterns(min_confidence=0.5)
+        assert len(results) == 1
+        assert results[0]["pattern_key"] == "python"
+
+
+class TestCrossProjectTable:
+    def test_table_exists(self, learning_db):
+        conn = learning_db._get_connection()
+        tables = [r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()]
+        conn.close()
+        assert "cross_project_behaviors" in tables
+
+    def test_store_transfer(self, learning_db):
+        pid = learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
+        tid = learning_db.store_cross_project("project_a", "project_b", pid, confidence=0.7)
+        assert isinstance(tid, int)
+
+    def test_get_transfers(self, learning_db):
+        pid = learning_db.store_behavioral_pattern("tag_success", "python", confidence=0.8)
+        learning_db.store_cross_project("proj_a", "proj_b", pid, confidence=0.7)
+        results = learning_db.get_cross_project_transfers(source_project="proj_a")
+        assert len(results) == 1
+        assert results[0]["target_project"] == "proj_b"
+
+    def test_existing_tables_untouched(self, learning_db):
+        """Existing 6 tables should still exist."""
+        conn = learning_db._get_connection()
+        tables = {r[0] for r in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
+        conn.close()
+        for expected in ["transferable_patterns", "workflow_patterns", "ranking_feedback", "ranking_models", "source_quality", "engagement_metrics"]:
+            assert expected in tables

package/src/learning/tests/test_learning_init_v28.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for unified learning status with v2.8 engines.
+"""
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestUnifiedLearningStatus:
+    def test_get_status_has_v28_engines(self):
+        """Status should include lifecycle, behavioral, compliance info."""
+        from learning import get_status
+        status = get_status()
+        assert "v28_engines" in status
+
+    def test_v28_engines_structure(self):
+        from learning import get_status
+        status = get_status()
+        engines = status["v28_engines"]
+        assert "lifecycle" in engines
+        assert "behavioral" in engines
+        assert "compliance" in engines
+
+    def test_lifecycle_status_included(self):
+        from learning import get_status
+        status = get_status()
+        lifecycle = status["v28_engines"]["lifecycle"]
+        assert "available" in lifecycle
+
+    def test_behavioral_status_included(self):
+        from learning import get_status
+        status = get_status()
+        behavioral = status["v28_engines"]["behavioral"]
+        assert "available" in behavioral
+
+    def test_compliance_status_included(self):
+        from learning import get_status
+        status = get_status()
+        compliance = status["v28_engines"]["compliance"]
+        assert "available" in compliance
+
+    def test_graceful_when_engines_unavailable(self):
+        """Status should not crash even if engine imports fail."""
+        from learning import get_status
+        status = get_status()
+        # Should always return a dict with v28_engines
+        assert isinstance(status["v28_engines"], dict)

package/src/learning/tests/test_outcome_signals.py

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for v2.8 outcome signal types in feedback collector.
+"""
+import pytest
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestOutcomeSignalTypes:
+    """Verify outcome signal types are registered and have correct values."""
+
+    def test_outcome_success_registered(self):
+        from learning.feedback_collector import FeedbackCollector
+        assert "outcome_success" in FeedbackCollector.SIGNAL_VALUES
+        assert FeedbackCollector.SIGNAL_VALUES["outcome_success"] == 1.0
+
+    def test_outcome_partial_registered(self):
+        from learning.feedback_collector import FeedbackCollector
+        assert "outcome_partial" in FeedbackCollector.SIGNAL_VALUES
+        assert FeedbackCollector.SIGNAL_VALUES["outcome_partial"] == 0.5
+
+    def test_outcome_failure_registered(self):
+        from learning.feedback_collector import FeedbackCollector
+        assert "outcome_failure" in FeedbackCollector.SIGNAL_VALUES
+        assert FeedbackCollector.SIGNAL_VALUES["outcome_failure"] == 0.0
+
+    def test_outcome_retry_registered(self):
+        from learning.feedback_collector import FeedbackCollector
+        assert "outcome_retry" in FeedbackCollector.SIGNAL_VALUES
+        assert FeedbackCollector.SIGNAL_VALUES["outcome_retry"] == 0.2
+
+    def test_existing_signals_unchanged(self):
+        """All 17 original signal types still present with correct values."""
+        from learning.feedback_collector import FeedbackCollector
+        SV = FeedbackCollector.SIGNAL_VALUES
+        assert SV["mcp_used_high"] == 1.0
+        assert SV["dashboard_thumbs_up"] == 1.0
+        assert SV["implicit_positive_timegap"] == 0.6
+        assert SV["passive_decay"] == 0.0
+        assert len(SV) == 21  # 17 original + 4 new
+
+    def test_total_signal_count(self):
+        """Should have exactly 21 signal types (17 + 4)."""
+        from learning.feedback_collector import FeedbackCollector
+        assert len(FeedbackCollector.SIGNAL_VALUES) == 21

package/src/learning/tests/test_project_context.py

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

package/src/learning/tests/test_schema_migration.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - Tests for v2.8 Schema Migration
+
+Tests that the v2.8.0 lifecycle + access control columns are added
+via backward-compatible ALTER TABLE migration in memory_store_v2.py.
+"""
+import json
+import sqlite3
+import sys
+import importlib
+from pathlib import Path
+
+import pytest
+
+# Ensure src/ is importable AND takes precedence over ~/.claude-memory/
+# (the installed production copy). Other test modules in this suite may
+# cause ~/.claude-memory to appear on sys.path earlier, so we must ensure
+# our development src/ directory wins.
+SRC_DIR = Path(__file__).resolve().parent.parent.parent  # src/
+_src_str = str(SRC_DIR)
+
+
+def _import_memory_store_v2():
+    """
+    Import MemoryStoreV2 from the development src/ directory.
+
+    When running in a full test suite, other test modules may cause
+    ~/.claude-memory/ (the installed production copy) to appear on sys.path
+    before src/. This helper ensures we always load from the correct location
+    by temporarily prioritizing src/ and invalidating any stale cached import.
+    """
+    # Ensure src/ is at position 0
+    if sys.path[0] != _src_str:
+        if _src_str in sys.path:
+            sys.path.remove(_src_str)
+        sys.path.insert(0, _src_str)
+
+    # If memory_store_v2 was already imported from a different location
+    # (e.g., ~/.claude-memory/), force a reimport from src/
+    mod = sys.modules.get("memory_store_v2")
+    if mod is not None and hasattr(mod, "__file__"):
+        mod_path = str(Path(mod.__file__).resolve().parent)
+        if mod_path != _src_str:
+            del sys.modules["memory_store_v2"]
+            # Also clear any cached submodule imports that may hold refs
+            for key in list(sys.modules.keys()):
+                m = sys.modules[key]
+                if m is not None and hasattr(m, "__file__") and m.__file__ and "memory_store_v2" in str(m.__file__):
+                    pass  # memory_store_v2 is not a package, no submodules
+
+    from memory_store_v2 import MemoryStoreV2
+    return MemoryStoreV2
+
+
+# ---------------------------------------------------------------------------
+# Helper — create a v2.7.6 schema database (WITHOUT lifecycle columns)
+# ---------------------------------------------------------------------------
+
+def _create_v276_database(db_path: Path) -> None:
+    """
+    Create a minimal memories table matching the v2.7.6 schema.
+    This deliberately omits the v2.8 lifecycle columns so the migration
+    can be verified.
+    """
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS memories (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            content TEXT NOT NULL,
+            summary TEXT,
+            project_path TEXT,
+            project_name TEXT,
+            tags TEXT,
+            category TEXT,
+            parent_id INTEGER,
+            tree_path TEXT,
+            depth INTEGER DEFAULT 0,
+            memory_type TEXT DEFAULT 'session',
+            importance INTEGER DEFAULT 5,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            last_accessed TIMESTAMP,
+            access_count INTEGER DEFAULT 0,
+            content_hash TEXT UNIQUE,
+            cluster_id INTEGER,
+            profile TEXT DEFAULT 'default',
+            FOREIGN KEY (parent_id) REFERENCES memories(id) ON DELETE CASCADE
+        )
+    """)
+    conn.commit()
+    conn.close()
+
+
+def _insert_test_memory(db_path: Path, content: str = "test memory content") -> int:
+    """Insert a single test memory into a v2.7.6 database and return its id."""
+    conn = sqlite3.connect(str(db_path))
+    cursor = conn.cursor()
+    cursor.execute(
+        "INSERT INTO memories (content, profile) VALUES (?, ?)",
+        (content, "default"),
+    )
+    conn.commit()
+    row_id = cursor.lastrowid
+    conn.close()
+    return row_id
+
+
+def _get_column_names(db_path: Path, table: str = "memories") -> set:
+    """Return the set of column names for a table."""
+    conn = sqlite3.connect(str(db_path))
+    cursor = conn.cursor()
+    cursor.execute(f"PRAGMA table_info({table})")
+    columns = {row[1] for row in cursor.fetchall()}
+    conn.close()
+    return columns
+
+
+def _get_index_names(db_path: Path) -> set:
+    """Return the set of index names in the database."""
+    conn = sqlite3.connect(str(db_path))
+    cursor = conn.cursor()
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='index'")
+    indexes = {row[0] for row in cursor.fetchall()}
+    conn.close()
+    return indexes
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def v276_db(tmp_path):
+    """
+    Create a temporary v2.7.6 schema database with one pre-existing memory.
+    Returns (db_path, memory_id).
+    """
+    db_path = tmp_path / "memory.db"
+    _create_v276_database(db_path)
+    mem_id = _insert_test_memory(db_path, "pre-existing memory from v2.7.6")
+    return db_path, mem_id
+
+
+@pytest.fixture
+def migrated_store(v276_db):
+    """
+    Initialize MemoryStoreV2 on the v2.7.6 database, triggering the migration.
+    Returns (store, db_path, pre_existing_memory_id).
+    """
+    db_path, mem_id = v276_db
+    MemoryStoreV2 = _import_memory_store_v2()
+    store = MemoryStoreV2(db_path=db_path)
+    return store, db_path, mem_id
+
+
+# ---------------------------------------------------------------------------
+# Tests
+# ---------------------------------------------------------------------------
+
+class TestV28SchemaMigration:
+    """Verify v2.8.0 lifecycle + access control migration."""
+
+    def test_lifecycle_state_column_added(self, migrated_store):
+        """After MemoryStoreV2 init, lifecycle_state column exists."""
+        _store, db_path, _mem_id = migrated_store
+        columns = _get_column_names(db_path)
+        assert "lifecycle_state" in columns, (
+            f"lifecycle_state column missing. Columns: {sorted(columns)}"
+        )
+
+    def test_existing_memories_get_active_state(self, migrated_store):
+        """Pre-existing memories get lifecycle_state='active' from DEFAULT."""
+        _store, db_path, mem_id = migrated_store
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT lifecycle_state FROM memories WHERE id = ?", (mem_id,)
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        assert row is not None, "Pre-existing memory not found after migration"
+        assert row[0] == "active", (
+            f"Expected lifecycle_state='active', got '{row[0]}'"
+        )
+
+    def test_access_level_column_added(self, migrated_store):
+        """access_level column exists with DEFAULT 'public'."""
+        _store, db_path, mem_id = migrated_store
+        columns = _get_column_names(db_path)
+        assert "access_level" in columns, (
+            f"access_level column missing. Columns: {sorted(columns)}"
+        )
+
+        # Verify default value on pre-existing row
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT access_level FROM memories WHERE id = ?", (mem_id,)
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        assert row is not None
+        assert row[0] == "public", (
+            f"Expected access_level='public', got '{row[0]}'"
+        )
+
+    def test_lifecycle_history_column_added(self, migrated_store):
+        """lifecycle_history column exists with DEFAULT '[]'."""
+        _store, db_path, mem_id = migrated_store
+        columns = _get_column_names(db_path)
+        assert "lifecycle_history" in columns, (
+            f"lifecycle_history column missing. Columns: {sorted(columns)}"
+        )
+
+        # Verify default value on pre-existing row
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT lifecycle_history FROM memories WHERE id = ?", (mem_id,)
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        assert row is not None
+        assert row[0] == "[]", (
+            f"Expected lifecycle_history='[]', got '{row[0]}'"
+        )
+        # Verify it's valid JSON
+        parsed = json.loads(row[0])
+        assert parsed == []
+
+    def test_lifecycle_updated_at_column_added(self, migrated_store):
+        """lifecycle_updated_at column exists (nullable, no default)."""
+        _store, db_path, mem_id = migrated_store
+        columns = _get_column_names(db_path)
+        assert "lifecycle_updated_at" in columns, (
+            f"lifecycle_updated_at column missing. Columns: {sorted(columns)}"
+        )
+
+        # Pre-existing rows should have NULL for this column
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute(
+            "SELECT lifecycle_updated_at FROM memories WHERE id = ?", (mem_id,)
+        )
+        row = cursor.fetchone()
+        conn.close()
+
+        assert row is not None
+        assert row[0] is None, (
+            f"Expected lifecycle_updated_at=NULL for pre-existing row, got '{row[0]}'"
+        )
+
+    def test_migration_is_idempotent(self, v276_db):
+        """Running migration twice (two MemoryStoreV2 inits) doesn't error."""
+        db_path, mem_id = v276_db
+        MemoryStoreV2 = _import_memory_store_v2()
+
+        # First init — migration runs
+        store1 = MemoryStoreV2(db_path=db_path)
+
+        # Second init — migration runs again (ALTER TABLE should be caught)
+        store2 = MemoryStoreV2(db_path=db_path)
+
+        # Both should succeed, columns should exist exactly once
+        columns = _get_column_names(db_path)
+        assert "lifecycle_state" in columns
+        assert "access_level" in columns
+        assert "lifecycle_history" in columns
+        assert "lifecycle_updated_at" in columns
+
+        # Pre-existing data should be intact
+        conn = sqlite3.connect(str(db_path))
+        cursor = conn.cursor()
+        cursor.execute("SELECT content FROM memories WHERE id = ?", (mem_id,))
+        row = cursor.fetchone()
+        conn.close()
+        assert row is not None
+        assert row[0] == "pre-existing memory from v2.7.6"
+
+    def test_existing_queries_still_work(self, migrated_store):
+        """list_all() and search() work after migration."""
+        store, db_path, mem_id = migrated_store
+
+        # list_all should return the pre-existing memory
+        all_memories = store.list_all(limit=10)
+        assert len(all_memories) >= 1, "list_all() returned no results after migration"
+
+        found = any(m["id"] == mem_id for m in all_memories)
+        assert found, (
+            f"Pre-existing memory id={mem_id} not found in list_all() results"
+        )
+
+        # Add a memory through the store API (so FTS is properly populated)
+        new_id = store.add_memory(
+            content="post-migration memory for search test",
+            tags=["test"],
+        )
+        assert new_id is not None, "add_memory() should succeed after migration"
+
+        # search should not crash (may return empty if TF-IDF vectors not rebuilt)
+        results = store.search("post-migration", limit=5)
+        assert isinstance(results, list), "search() should return a list"
+
+    def test_v28_indexes_created(self, migrated_store):
+        """v2.8.0 indexes for lifecycle_state and access_level exist."""
+        _store, db_path, _mem_id = migrated_store
+        indexes = _get_index_names(db_path)
+        assert "idx_lifecycle_state" in indexes, (
+            f"idx_lifecycle_state index missing. Indexes: {sorted(indexes)}"
+        )
+        assert "idx_access_level" in indexes, (
+            f"idx_access_level index missing. Indexes: {sorted(indexes)}"
+        )

package/src/learning/tests/test_signal_inference.py

@@ -1,12 +1,10 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Signal Inference Engine Tests (v2.7.4)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""SuperLocalMemory V2 - Signal Inference Engine Tests (v2.7.4)
 
 Tests for the implicit feedback signal inference system.
 """
-
 import time
 import threading
 import pytest
@@ -341,14 +339,14 @@ class TestFeedbackCollectorImplicit:
 
 
 class TestFeatureExpansion:
-    """Test the 10→12 feature vector expansion."""
+    """Test the 10→12→20 feature vector expansion."""
 
-    def test_feature_count_is_12(self):
-        """Feature vector should have 12 dimensions."""
+    def test_feature_count_is_20(self):
+        """Feature vector should have 20 dimensions (v2.8)."""
         sys.path.insert(0, str(Path(__file__).parent.parent))
         from feature_extractor import FEATURE_NAMES, NUM_FEATURES
-        assert NUM_FEATURES == 12
-        assert len(FEATURE_NAMES) == 12
+        assert NUM_FEATURES == 20
+        assert len(FEATURE_NAMES) == 20
 
     def test_new_features_present(self):
         """signal_count and avg_signal_value should be in feature names."""
@@ -359,8 +357,8 @@ class TestFeatureExpansion:
         assert FEATURE_NAMES.index('signal_count') == 10
         assert FEATURE_NAMES.index('avg_signal_value') == 11
 
-    def test_extract_features_returns_12(self):
-        """Extract should return 12-element vector."""
+    def test_extract_features_returns_20(self):
+        """Extract should return 20-element vector (v2.8)."""
         sys.path.insert(0, str(Path(__file__).parent.parent))
         from feature_extractor import FeatureExtractor
         fe = FeatureExtractor()
@@ -368,7 +366,7 @@ class TestFeatureExpansion:
             {'id': 1, 'content': 'test', 'importance': 5},
             'test'
         )
-        assert len(features) == 12
+        assert len(features) == 20
 
     def test_signal_features_with_stats(self):
         """Signal features should use provided stats."""

package/src/learning/tests/test_source_quality.py

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

package/src/learning/tests/test_synthetic_bootstrap.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for SyntheticBootstrapper (v2.7)
-Copyright (c) 2026 Varun Pratap Bhardwaj
-Licensed under MIT License
-"""
-
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
 import sqlite3
 from pathlib import Path
 
@@ -258,7 +254,7 @@ class TestGenerateSyntheticData:
             assert "label" in r
             assert "source" in r
             assert "features" in r
-            assert len(r["features"]) == 12  # 12-dimensional feature vector (v2.7.4)
+            assert len(r["features"]) == 20  # 20-dimensional feature vector (v2.8)
 
     def test_labels_in_range(self, bootstrapper_with_data):
         records = bootstrapper_with_data.generate_synthetic_training_data()

package/src/learning/tests/test_workflow_miner.py

@@ -1,10 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Tests for WorkflowPatternMiner (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/workflow_pattern_miner.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Workflow Pattern Miner (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)
 """
 WorkflowPatternMiner -- Layer 3: Sliding-window sequence and temporal pattern mining.