superlocalmemory 2.7.6 → 2.8.0

package/src/compliance/tests/test_audit_logger.py

@@ -0,0 +1,98 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for audit logger EventBus listener.
+"""
+import tempfile, os, sys, sqlite3
+from datetime import datetime
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+class TestAuditLogger:
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.audit_db_path = os.path.join(self.tmp_dir, "audit.db")
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_creation(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        assert logger is not None
+
+    def test_logs_memory_created(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({"event_type": "memory.created", "memory_id": 1, "payload": {}, "timestamp": datetime.now().isoformat(), "source_agent": "user"})
+        conn = sqlite3.connect(self.audit_db_path)
+        rows = conn.execute("SELECT * FROM audit_events WHERE event_type='memory.created'").fetchall()
+        conn.close()
+        assert len(rows) == 1
+
+    def test_logs_memory_recalled(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({"event_type": "memory.recalled", "memory_id": 2, "payload": {"query": "test"}, "timestamp": datetime.now().isoformat(), "source_agent": "agent_a"})
+        conn = sqlite3.connect(self.audit_db_path)
+        rows = conn.execute("SELECT * FROM audit_events WHERE event_type='memory.recalled'").fetchall()
+        conn.close()
+        assert len(rows) == 1
+
+    def test_logs_memory_deleted(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({"event_type": "memory.deleted", "memory_id": 3, "payload": {}, "timestamp": datetime.now().isoformat(), "source_agent": "user"})
+        conn = sqlite3.connect(self.audit_db_path)
+        rows = conn.execute("SELECT * FROM audit_events WHERE event_type='memory.deleted'").fetchall()
+        conn.close()
+        assert len(rows) == 1
+
+    def test_hash_chain_maintained(self):
+        """Multiple events maintain hash chain integrity."""
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        for i in range(5):
+            logger.handle_event({"event_type": "memory.created", "memory_id": i, "payload": {}, "timestamp": datetime.now().isoformat(), "source_agent": "user"})
+        from compliance.audit_db import AuditDB
+        db = AuditDB(self.audit_db_path)
+        result = db.verify_chain()
+        assert result["valid"] is True
+        assert result["entries_checked"] == 5
+
+    def test_logs_lifecycle_transitions(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({"event_type": "lifecycle.transitioned", "memory_id": 1, "payload": {"from_state": "active", "to_state": "warm"}, "timestamp": datetime.now().isoformat(), "source_agent": "scheduler"})
+        conn = sqlite3.connect(self.audit_db_path)
+        rows = conn.execute("SELECT * FROM audit_events").fetchall()
+        conn.close()
+        assert len(rows) == 1
+
+    def test_ignores_unknown_gracefully(self):
+        """Unknown event types logged without error."""
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({"event_type": "unknown.event", "payload": {}, "timestamp": datetime.now().isoformat(), "source_agent": "test"})
+        assert logger.events_logged >= 1
+
+    def test_graceful_on_malformed_event(self):
+        """Malformed events don't crash the logger."""
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        logger.handle_event({})  # Empty event
+        logger.handle_event({"event_type": "test"})  # Missing fields
+        # Should not crash
+
+    def test_register_with_eventbus(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        result = logger.register_with_eventbus()
+        assert isinstance(result, bool)
+
+    def test_get_status(self):
+        from compliance.audit_logger import AuditLogger
+        logger = AuditLogger(self.audit_db_path)
+        status = logger.get_status()
+        assert "events_logged" in status
+        assert "registered" in status

package/src/compliance/tests/test_mcp_audit.py

@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for audit_trail MCP tool handler.
+
+Validates the MCP wrapper around AuditDB — tests empty trail, event logging,
+event_type and actor filtering, and hash chain verification.
+"""
+import asyncio
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestMCPAuditTrail:
+    """Tests for the audit_trail tool handler."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "audit.db")
+
+    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_empty_trail(self):
+        """Fresh audit DB should return count=0."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail())
+        assert result["success"] is True
+        assert result["count"] == 0
+        assert result["events"] == []
+
+    def test_verify_empty_chain(self):
+        """Hash chain verification on empty DB should be valid."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail(verify_chain=True))
+        assert result["success"] is True
+        assert result["chain_valid"] is True
+        assert result["chain_entries"] == 0
+
+    def test_query_with_events(self):
+        """After logging events, query should return them."""
+        from compliance.audit_db import AuditDB
+
+        db = AuditDB(self.db_path)
+        db.log_event("memory.created", actor="user", resource_id=1)
+        db.log_event("memory.recalled", actor="agent_a", resource_id=1)
+        db.log_event("memory.created", actor="user", resource_id=2)
+
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail())
+        assert result["success"] is True
+        assert result["count"] == 3
+
+    def test_filter_by_event_type(self):
+        """Filtering by event_type should narrow results."""
+        from compliance.audit_db import AuditDB
+
+        db = AuditDB(self.db_path)
+        db.log_event("memory.created", actor="user", resource_id=1)
+        db.log_event("memory.recalled", actor="agent_a", resource_id=1)
+
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail(event_type="memory.created"))
+        assert result["count"] == 1
+        assert result["events"][0]["event_type"] == "memory.created"
+
+    def test_filter_by_actor(self):
+        """Filtering by actor should narrow results."""
+        from compliance.audit_db import AuditDB
+
+        db = AuditDB(self.db_path)
+        db.log_event("memory.created", actor="user", resource_id=1)
+        db.log_event("memory.recalled", actor="agent_a", resource_id=1)
+
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail(actor="agent_a"))
+        assert result["count"] == 1
+        assert result["events"][0]["actor"] == "agent_a"
+
+    def test_verify_chain_with_events(self):
+        """Hash chain with events should verify successfully."""
+        from compliance.audit_db import AuditDB
+
+        db = AuditDB(self.db_path)
+        db.log_event("memory.created", actor="user", resource_id=1)
+        db.log_event("memory.recalled", actor="user", resource_id=1)
+        db.log_event("memory.updated", actor="user", resource_id=1)
+
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail(verify_chain=True))
+        assert result["success"] is True
+        assert result["chain_valid"] is True
+        assert result["chain_entries"] == 3
+
+    def test_limit_parameter(self):
+        """Limit parameter should cap returned events."""
+        from compliance.audit_db import AuditDB
+
+        db = AuditDB(self.db_path)
+        for i in range(10):
+            db.log_event("memory.created", actor="user", resource_id=i)
+
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_AUDIT_DB = self.db_path
+
+        result = self._run(tools.audit_trail(limit=3))
+        assert result["count"] == 3

package/src/compliance/tests/test_mcp_retention_policy.py

@@ -0,0 +1,125 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for set_retention_policy MCP tool handler.
+
+Validates the MCP wrapper around RetentionPolicyManager — tests policy
+creation with tags, project scope, and various framework types.
+"""
+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_memory_db(db_path: str) -> None:
+    """Create a minimal memory.db for RetentionPolicyManager."""
+    conn = sqlite3.connect(db_path)
+    conn.execute(
+        """CREATE TABLE memories (
+            id INTEGER PRIMARY KEY,
+            content TEXT,
+            tags TEXT DEFAULT '[]',
+            project_name TEXT,
+            lifecycle_state TEXT DEFAULT 'active',
+            profile TEXT DEFAULT 'default'
+        )"""
+    )
+    conn.commit()
+    conn.close()
+
+
+class TestMCPRetentionPolicy:
+    """Tests for the set_retention_policy tool handler."""
+
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.db_path = os.path.join(self.tmp_dir, "memory.db")
+        _create_memory_db(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_create_gdpr_policy(self):
+        """Creating a GDPR tombstone policy should return success with policy_id."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(
+            tools.set_retention_policy(
+                "GDPR Erasure", "gdpr", 0, "tombstone", ["gdpr"]
+            )
+        )
+        assert result["success"] is True
+        assert isinstance(result["policy_id"], int)
+        assert result["policy_id"] > 0
+        assert result["name"] == "GDPR Erasure"
+        assert result["framework"] == "gdpr"
+
+    def test_create_hipaa_policy(self):
+        """Creating a HIPAA retention policy should succeed."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(
+            tools.set_retention_policy(
+                "HIPAA Retention", "hipaa", 2190, "retain", ["medical"]
+            )
+        )
+        assert result["success"] is True
+        assert result["framework"] == "hipaa"
+
+    def test_create_policy_with_project(self):
+        """Policy scoped to a project should succeed."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(
+            tools.set_retention_policy(
+                "Internal Retention",
+                "internal",
+                365,
+                "archive",
+                applies_to_project="myproject",
+            )
+        )
+        assert result["success"] is True
+
+    def test_create_policy_with_tags_and_project(self):
+        """Policy with both tags and project scope should succeed."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        result = self._run(
+            tools.set_retention_policy(
+                "EU AI Act",
+                "eu_ai_act",
+                1825,
+                "retain",
+                applies_to_tags=["ai-decision"],
+                applies_to_project="ml-pipeline",
+            )
+        )
+        assert result["success"] is True
+
+    def test_multiple_policies_unique_ids(self):
+        """Consecutive policies should get distinct IDs."""
+        import mcp_tools_v28 as tools
+        tools.DEFAULT_MEMORY_DB = self.db_path
+
+        r1 = self._run(
+            tools.set_retention_policy("Policy A", "gdpr", 0, "tombstone", ["a"])
+        )
+        r2 = self._run(
+            tools.set_retention_policy("Policy B", "hipaa", 365, "retain", ["b"])
+        )
+        assert r1["policy_id"] != r2["policy_id"]

package/src/compliance/tests/test_retention_manager.py

@@ -0,0 +1,131 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for compliance retention manager.
+"""
+import sqlite3
+import tempfile
+import os
+import sys
+import json
+from datetime import datetime, timedelta
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+
+class TestComplianceRetentionManager:
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.memory_db_path = os.path.join(self.tmp_dir, "memory.db")
+        self.audit_db_path = os.path.join(self.tmp_dir, "audit.db")
+
+        # Create memory.db with test data
+        conn = sqlite3.connect(self.memory_db_path)
+        conn.execute("""
+            CREATE TABLE memories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                content TEXT NOT NULL,
+                importance INTEGER DEFAULT 5,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_accessed TIMESTAMP,
+                access_count INTEGER DEFAULT 0,
+                lifecycle_state TEXT DEFAULT 'active',
+                lifecycle_updated_at TIMESTAMP,
+                lifecycle_history TEXT DEFAULT '[]',
+                access_level TEXT DEFAULT 'public',
+                profile TEXT DEFAULT 'default',
+                tags TEXT DEFAULT '[]',
+                project_name TEXT
+            )
+        """)
+        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('user PII data', '[\"gdpr\",\"pii\"]', 'eu-app')")
+        conn.execute("INSERT INTO memories (content, tags, project_name) VALUES ('medical record', '[\"hipaa\"]', 'healthcare')")
+        conn.execute("INSERT INTO memories (content, tags) VALUES ('general note', '[]')")
+        conn.commit()
+        conn.close()
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_creation(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        assert mgr is not None
+
+    def test_create_gdpr_policy(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        pid = mgr.create_retention_rule(
+            name="GDPR Right to Erasure",
+            framework="gdpr",
+            retention_days=0,
+            action="tombstone",
+            applies_to={"tags": ["gdpr"]},
+        )
+        assert isinstance(pid, int)
+
+    def test_create_eu_ai_act_policy(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        pid = mgr.create_retention_rule(
+            name="EU AI Act Audit Retention",
+            framework="eu_ai_act",
+            retention_days=3650,
+            action="retain_audit",
+            applies_to={"tags": ["gdpr"]},
+        )
+        assert pid > 0
+
+    def test_gdpr_erasure_tombstones_memory(self):
+        """GDPR erasure request tombstones the memory."""
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        result = mgr.execute_erasure_request(memory_id=1, framework="gdpr", requested_by="data_subject")
+        assert result["success"] is True
+        assert result["action"] == "tombstoned"
+        # Verify in DB
+        conn = sqlite3.connect(self.memory_db_path)
+        row = conn.execute("SELECT lifecycle_state FROM memories WHERE id=1").fetchone()
+        conn.close()
+        assert row[0] == "tombstoned"
+
+    def test_gdpr_erasure_preserves_audit(self):
+        """GDPR erasure logs the action to audit.db."""
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        mgr.execute_erasure_request(memory_id=1, framework="gdpr", requested_by="data_subject")
+        conn = sqlite3.connect(self.audit_db_path)
+        rows = conn.execute("SELECT * FROM audit_events WHERE event_type='retention.erasure'").fetchall()
+        conn.close()
+        assert len(rows) >= 1
+
+    def test_list_rules(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        mgr.create_retention_rule("GDPR", "gdpr", 0, "tombstone", {"tags": ["gdpr"]})
+        mgr.create_retention_rule("HIPAA", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
+        rules = mgr.list_rules()
+        assert len(rules) == 2
+
+    def test_evaluate_memory_against_rules(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        mgr.create_retention_rule("HIPAA Retention", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
+        result = mgr.evaluate_memory(2)  # Memory 2 has hipaa tag
+        assert result is not None
+        assert result["rule_name"] == "HIPAA Retention"
+
+    def test_no_rule_match_returns_none(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        mgr.create_retention_rule("HIPAA", "hipaa", 2555, "retain", {"tags": ["hipaa"]})
+        result = mgr.evaluate_memory(3)  # Memory 3 has no hipaa tag
+        assert result is None
+
+    def test_get_compliance_status(self):
+        from compliance.retention_manager import ComplianceRetentionManager
+        mgr = ComplianceRetentionManager(self.memory_db_path, self.audit_db_path)
+        status = mgr.get_compliance_status()
+        assert "rules_count" in status
+        assert "frameworks" in status

package/src/compliance/tests/test_retention_scheduler.py

@@ -0,0 +1,99 @@
+# SPDX-License-Identifier: MIT
+# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
+"""Tests for retention policy background scheduler.
+"""
+import sqlite3, tempfile, os, sys, json, threading
+from datetime import datetime, timedelta
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
+
+class TestRetentionScheduler:
+    def setup_method(self):
+        self.tmp_dir = tempfile.mkdtemp()
+        self.memory_db = os.path.join(self.tmp_dir, "memory.db")
+        self.audit_db = os.path.join(self.tmp_dir, "audit.db")
+        conn = sqlite3.connect(self.memory_db)
+        conn.execute("""
+            CREATE TABLE memories (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                content TEXT NOT NULL,
+                importance INTEGER DEFAULT 5,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_accessed TIMESTAMP,
+                access_count INTEGER DEFAULT 0,
+                lifecycle_state TEXT DEFAULT 'active',
+                lifecycle_updated_at TIMESTAMP,
+                lifecycle_history TEXT DEFAULT '[]',
+                access_level TEXT DEFAULT 'public',
+                profile TEXT DEFAULT 'default',
+                tags TEXT DEFAULT '[]',
+                project_name TEXT
+            )
+        """)
+        now = datetime.now()
+        # Memory 1: old GDPR data (created 400 days ago)
+        conn.execute("INSERT INTO memories (content, tags, created_at, lifecycle_state) VALUES (?, ?, ?, ?)",
+            ("old PII data", '["gdpr"]', (now - timedelta(days=400)).isoformat(), "active"))
+        # Memory 2: recent data
+        conn.execute("INSERT INTO memories (content, tags) VALUES (?, ?)",
+            ("fresh data", '[]'))
+        # Memory 3: tombstoned (should be checked for final deletion)
+        conn.execute("INSERT INTO memories (content, lifecycle_state, created_at) VALUES (?, ?, ?)",
+            ("tombstoned data", "tombstoned", (now - timedelta(days=100)).isoformat()))
+        conn.commit()
+        conn.close()
+
+    def teardown_method(self):
+        import shutil
+        shutil.rmtree(self.tmp_dir, ignore_errors=True)
+
+    def test_creation(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db)
+        assert sched is not None
+
+    def test_default_interval(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db)
+        assert sched.interval_seconds == 86400  # 24 hours
+
+    def test_run_now(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db)
+        result = sched.run_now()
+        assert "timestamp" in result
+        assert "actions" in result
+
+    def test_start_and_stop(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=3600)
+        sched.start()
+        assert sched.is_running is True
+        sched.stop()
+        assert sched.is_running is False
+
+    def test_thread_is_daemon(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=3600)
+        sched.start()
+        assert sched._timer.daemon is True
+        sched.stop()
+
+    def test_manual_trigger_works(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db)
+        result = sched.run_now()
+        assert isinstance(result["actions"], list)
+
+    def test_configurable_interval(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db, interval_seconds=7200)
+        assert sched.interval_seconds == 7200
+
+    def test_result_structure(self):
+        from compliance.retention_scheduler import RetentionScheduler
+        sched = RetentionScheduler(self.memory_db, self.audit_db)
+        result = sched.run_now()
+        assert "timestamp" in result
+        assert "actions" in result
+        assert "rules_evaluated" in result

package/src/db_connection_manager.py

@@ -1,16 +1,6 @@
 #!/usr/bin/env python3
-"""
-SuperLocalMemory V2 - Database Connection Manager
-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)
 """
 DbConnectionManager — Thread-safe SQLite connection management with WAL mode.