superlocalmemory 2.8.6 → 3.0.1

package/src/lifecycle/tests/test_compaction.py

@@ -1,179 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for compaction engine — content archival and restoration.
-"""
-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 TestCompactionEngine:
-    """Test memory compaction and restoration."""
-
-    def setup_method(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self.db_path = os.path.join(self.tmp_dir, "test.db")
-        conn = sqlite3.connect(self.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 '[]',
-                summary TEXT
-            )
-        """)
-        conn.execute("""
-            CREATE TABLE IF NOT EXISTS memory_archive (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                memory_id INTEGER UNIQUE NOT NULL,
-                full_content TEXT NOT NULL,
-                archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE
-            )
-        """)
-        conn.execute("CREATE INDEX IF NOT EXISTS idx_archive_memory ON memory_archive(memory_id)")
-
-        # Memory 1: Long content suitable for compaction
-        long_content = (
-            "The Python programming language is widely used for machine learning and data science. "
-            "It provides libraries like scikit-learn, TensorFlow, and PyTorch for building models. "
-            "Python's simplicity and readability make it ideal for rapid prototyping. "
-            "The ecosystem includes tools for data preprocessing, visualization, and deployment. "
-            "Many enterprise applications use Python for backend services and API development."
-        )
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, tags) VALUES (?, ?, ?, ?)",
-            (long_content, 5, "cold", '["python","ml"]'),
-        )
-        # Memory 2: Short content
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state) VALUES (?, ?, ?)",
-            ("brief note about testing", 3, "cold"),
-        )
-        # Memory 3: Already archived
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state) VALUES (?, ?, ?)",
-            ("[COMPACTED] Key entities: database, SQL", 5, "archived"),
-        )
-        conn.execute(
-            "INSERT INTO memory_archive (memory_id, full_content) VALUES (?, ?)",
-            (3, "The database management system uses SQL for querying and PostgreSQL for storage."),
-        )
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        import shutil
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def test_compact_memory_archives_content(self):
-        """Compaction stores full content in memory_archive."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.compact_memory(1)
-        assert result["success"] is True
-        # Verify archive has full content
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT full_content FROM memory_archive WHERE memory_id=1").fetchone()
-        conn.close()
-        assert row is not None
-        assert "Python programming" in row[0]
-
-    def test_compact_memory_replaces_content(self):
-        """Compacted memory content is replaced with summary + entities."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        engine.compact_memory(1)
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT content FROM memories WHERE id=1").fetchone()
-        conn.close()
-        # Content should be shorter than original
-        assert len(row[0]) < 300
-        assert "[COMPACTED]" in row[0]
-
-    def test_compact_preserves_key_entities(self):
-        """Compacted content preserves key entities/terms."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.compact_memory(1)
-        assert "entities" in result
-        assert len(result["entities"]) >= 3
-        # Should extract key terms like "python", "learning", "data"
-        entities_lower = [e.lower() for e in result["entities"]]
-        assert any("python" in e for e in entities_lower)
-
-    def test_compact_preserves_tags(self):
-        """Compaction does NOT remove tags from the memory."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        engine.compact_memory(1)
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT tags FROM memories WHERE id=1").fetchone()
-        conn.close()
-        assert row[0] is not None
-        tags = json.loads(row[0])
-        assert "python" in tags
-
-    def test_restore_memory_from_archive(self):
-        """Restoring a compacted memory brings back full content."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.restore_memory(3)  # Already archived memory
-        assert result["success"] is True
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT content FROM memories WHERE id=3").fetchone()
-        conn.close()
-        assert "database management" in row[0]
-
-    def test_restore_cleans_archive(self):
-        """After restoration, the archive entry is removed."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        engine.restore_memory(3)
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT * FROM memory_archive WHERE memory_id=3").fetchone()
-        conn.close()
-        assert row is None
-
-    def test_dry_run_no_changes(self):
-        """dry_run mode shows what would happen without modifying DB."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.compact_memory(1, dry_run=True)
-        assert result["success"] is True
-        assert result["dry_run"] is True
-        # Verify DB was NOT modified
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT content FROM memories WHERE id=1").fetchone()
-        archive = conn.execute("SELECT * FROM memory_archive WHERE memory_id=1").fetchone()
-        conn.close()
-        assert "Python programming" in row[0]  # Original content still there
-        assert archive is None  # No archive entry created
-
-    def test_compact_nonexistent_memory(self):
-        """Compacting nonexistent memory returns failure."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.compact_memory(999)
-        assert result["success"] is False
-
-    def test_restore_nonexistent_archive(self):
-        """Restoring memory without archive entry returns failure."""
-        from lifecycle.compaction_engine import CompactionEngine
-        engine = CompactionEngine(self.db_path)
-        result = engine.restore_memory(1)  # Memory 1 has no archive
-        assert result["success"] is False

package/src/lifecycle/tests/test_lifecycle_engine.py

@@ -1,137 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for lifecycle state machine transitions.
-"""
-import sqlite3
-import tempfile
-import os
-import sys
-import json
-import pytest
-
-# Ensure src/ is importable and takes precedence (matches existing test pattern)
-from pathlib import Path
-SRC_DIR = Path(__file__).resolve().parent.parent.parent  # src/
-_src_str = str(SRC_DIR)
-if _src_str not in sys.path:
-    sys.path.insert(0, _src_str)
-
-
-class TestLifecycleStates:
-    """Test state definitions and valid transitions."""
-
-    def setup_method(self):
-        self.db_fd, self.db_path = tempfile.mkstemp(suffix=".db")
-        conn = sqlite3.connect(self.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'
-            )
-        """)
-        conn.execute("""
-            INSERT INTO memories (content, importance, lifecycle_state)
-            VALUES ('test memory', 5, 'active')
-        """)
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        os.close(self.db_fd)
-        os.unlink(self.db_path)
-
-    def test_valid_states(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        assert set(engine.STATES) == {"active", "warm", "cold", "archived", "tombstoned"}
-
-    def test_valid_transition_active_to_warm(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        assert engine.is_valid_transition("active", "warm") is True
-
-    def test_invalid_transition_active_to_archived(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        assert engine.is_valid_transition("active", "archived") is False
-
-    def test_reactivation_always_valid(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        for state in ["warm", "cold", "archived"]:
-            assert engine.is_valid_transition(state, "active") is True
-
-    def test_tombstoned_is_terminal(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        for state in engine.STATES:
-            if state != "tombstoned":
-                assert engine.is_valid_transition("tombstoned", state) is False
-
-    def test_transition_memory(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        result = engine.transition_memory(1, "warm", reason="no_access_30d")
-        assert result["success"] is True
-        assert result["from_state"] == "active"
-        assert result["to_state"] == "warm"
-
-    def test_transition_updates_db(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        engine.transition_memory(1, "warm", reason="no_access_30d")
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT lifecycle_state FROM memories WHERE id=1").fetchone()
-        conn.close()
-        assert row[0] == "warm"
-
-    def test_transition_records_history(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        engine.transition_memory(1, "warm", reason="no_access_30d")
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT lifecycle_history FROM memories WHERE id=1").fetchone()
-        conn.close()
-        history = json.loads(row[0])
-        assert len(history) == 1
-        assert history[0]["from"] == "active"
-        assert history[0]["to"] == "warm"
-        assert history[0]["reason"] == "no_access_30d"
-
-    def test_invalid_transition_rejected(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        result = engine.transition_memory(1, "archived", reason="skip")
-        assert result["success"] is False
-        assert "invalid" in result["error"].lower()
-
-    def test_get_memory_state(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        state = engine.get_memory_state(1)
-        assert state == "active"
-
-    def test_get_state_distribution(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        dist = engine.get_state_distribution()
-        assert dist["active"] >= 1
-        assert dist["warm"] == 0
-
-    def test_reactivation_on_access(self):
-        from lifecycle.lifecycle_engine import LifecycleEngine
-        engine = LifecycleEngine(self.db_path)
-        engine.transition_memory(1, "warm", reason="aged")
-        result = engine.reactivate_memory(1, trigger="recall")
-        assert result["success"] is True
-        assert result["from_state"] == "warm"
-        assert result["to_state"] == "active"

package/src/lifecycle/tests/test_lifecycle_evaluation.py

@@ -1,177 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for lifecycle evaluation rules — which memories should transition.
-"""
-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 TestLifecycleEvaluation:
-    """Test evaluation rules for memory lifecycle transitions."""
-
-    def setup_method(self):
-        # Create temp dir for DB + config isolation
-        self.tmp_dir = tempfile.mkdtemp()
-        self.db_path = os.path.join(self.tmp_dir, "test.db")
-        conn = sqlite3.connect(self.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'
-            )
-        """)
-        now = datetime.now()
-
-        # Memory 1: Active, stale (35d), low importance (5) → should recommend WARM
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("stale low importance", 5, "active", (now - timedelta(days=35)).isoformat(), (now - timedelta(days=100)).isoformat()),
-        )
-        # Memory 2: Active, recent (10d), low importance (5) → should STAY
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("recent access", 5, "active", (now - timedelta(days=10)).isoformat(), (now - timedelta(days=100)).isoformat()),
-        )
-        # Memory 3: Active, stale (35d), HIGH importance (8) → should STAY (importance resists)
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("stale high importance", 8, "active", (now - timedelta(days=35)).isoformat(), (now - timedelta(days=100)).isoformat()),
-        )
-        # Memory 4: Warm, stale (95d), low importance (3) → should recommend COLD
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("warm stale", 3, "warm", (now - timedelta(days=95)).isoformat(), (now - timedelta(days=200)).isoformat()),
-        )
-        # Memory 5: Cold, very stale (200d), importance 5 → should recommend ARCHIVED
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("cold very stale", 5, "cold", (now - timedelta(days=200)).isoformat(), (now - timedelta(days=300)).isoformat()),
-        )
-        # Memory 6: Active, NULL last_accessed, created 40d ago, importance 4 → WARM (uses created_at)
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("never accessed", 4, "active", None, (now - timedelta(days=40)).isoformat()),
-        )
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        import shutil
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def test_active_to_warm_stale_low_importance(self):
-        """Memory 1: stale 35d, importance 5 → recommend ACTIVE→WARM."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(1)
-        assert rec is not None
-        assert rec["from_state"] == "active"
-        assert rec["to_state"] == "warm"
-        assert rec["memory_id"] == 1
-
-    def test_active_stays_recent_access(self):
-        """Memory 2: accessed 10d ago → no transition recommended."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(2)
-        assert rec is None
-
-    def test_active_stays_high_importance(self):
-        """Memory 3: importance 8 resists transition even when stale."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(3)
-        assert rec is None
-
-    def test_warm_to_cold_stale(self):
-        """Memory 4: warm, stale 95d, importance 3 → recommend COLD."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(4)
-        assert rec is not None
-        assert rec["from_state"] == "warm"
-        assert rec["to_state"] == "cold"
-
-    def test_cold_to_archived(self):
-        """Memory 5: cold, stale 200d → recommend ARCHIVED."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(5)
-        assert rec is not None
-        assert rec["from_state"] == "cold"
-        assert rec["to_state"] == "archived"
-
-    def test_never_accessed_uses_created_at(self):
-        """Memory 6: NULL last_accessed, created 40d ago → recommend WARM."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(6)
-        assert rec is not None
-        assert rec["to_state"] == "warm"
-
-    def test_retention_override_skips_memory(self):
-        """Memory 1 should be skipped when in retention_overrides set."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(1, retention_overrides={1})
-        assert rec is None
-
-    def test_evaluate_memories_returns_recommendations(self):
-        """Full scan should return list with recommendations for eligible memories."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        recs = evaluator.evaluate_memories()
-        # Should recommend: Memory 1 (active→warm), 4 (warm→cold), 5 (cold→archived), 6 (active→warm)
-        assert isinstance(recs, list)
-        assert len(recs) >= 3  # At least memories 1, 4, 5
-        rec_ids = {r["memory_id"] for r in recs}
-        assert 1 in rec_ids  # stale active
-        assert 4 in rec_ids  # stale warm
-        assert 5 in rec_ids  # stale cold
-
-    def test_evaluate_memories_excludes_retained(self):
-        """evaluate_memories with retention_overrides skips those memory IDs."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        recs = evaluator.evaluate_memories(retention_overrides={1, 4})
-        rec_ids = {r["memory_id"] for r in recs}
-        assert 1 not in rec_ids
-        assert 4 not in rec_ids
-        assert 5 in rec_ids  # cold→archived not overridden
-
-    def test_custom_config_thresholds(self):
-        """Custom config should override default thresholds."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        # Write custom config: raise active_to_warm threshold to 50 days
-        config_path = os.path.join(self.tmp_dir, "lifecycle_config.json")
-        with open(config_path, "w") as f:
-            json.dump({
-                "active_to_warm": {"no_access_days": 50, "max_importance": 6}
-            }, f)
-        evaluator = LifecycleEvaluator(self.db_path, config_path=config_path)
-        # Memory 1 is stale 35d — below new 50d threshold → no recommendation
-        rec = evaluator.evaluate_single(1)
-        assert rec is None
-
-    def test_evaluate_single_nonexistent_memory(self):
-        """Evaluating a nonexistent memory returns None."""
-        from lifecycle.lifecycle_evaluator import LifecycleEvaluator
-        evaluator = LifecycleEvaluator(self.db_path)
-        rec = evaluator.evaluate_single(999)
-        assert rec is None

package/src/lifecycle/tests/test_lifecycle_scheduler.py

@@ -1,127 +0,0 @@
-# SPDX-License-Identifier: MIT
-# Copyright (c) 2026 SuperLocalMemory (superlocalmemory.com)
-"""Tests for lifecycle background scheduler.
-"""
-import sqlite3
-import tempfile
-import os
-import sys
-import time
-import threading
-from datetime import datetime, timedelta
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent.parent))
-
-
-class TestLifecycleScheduler:
-    """Test lifecycle scheduler background evaluation."""
-
-    def setup_method(self):
-        self.tmp_dir = tempfile.mkdtemp()
-        self.db_path = os.path.join(self.tmp_dir, "test.db")
-        conn = sqlite3.connect(self.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'
-            )
-        """)
-        now = datetime.now()
-        # Insert a stale memory that should be evaluated for transition
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("stale memory", 3, "active", (now - timedelta(days=45)).isoformat(), (now - timedelta(days=100)).isoformat()),
-        )
-        # Insert a fresh memory that should stay
-        conn.execute(
-            "INSERT INTO memories (content, importance, lifecycle_state, last_accessed, created_at) VALUES (?, ?, ?, ?, ?)",
-            ("fresh memory", 8, "active", now.isoformat(), (now - timedelta(days=10)).isoformat()),
-        )
-        conn.commit()
-        conn.close()
-
-    def teardown_method(self):
-        import shutil
-        shutil.rmtree(self.tmp_dir, ignore_errors=True)
-
-    def test_scheduler_creation(self):
-        """Scheduler can be created with default settings."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path)
-        assert scheduler is not None
-        assert scheduler.interval_seconds == 21600  # 6 hours default
-
-    def test_run_now_executes_evaluation(self):
-        """Manual trigger runs evaluation and transitions eligible memories."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path)
-        result = scheduler.run_now()
-        assert result is not None
-        assert "evaluation" in result
-        assert "enforcement" in result
-
-    def test_run_now_transitions_stale_memories(self):
-        """run_now should transition stale memories."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path)
-        result = scheduler.run_now()
-        # Memory 1 (stale 45d, importance 3) should be recommended for transition
-        eval_recs = result["evaluation"]["recommendations"]
-        if eval_recs:
-            transitioned = result["evaluation"]["transitioned"]
-            assert transitioned >= 1
-
-    def test_fresh_memory_stays_active(self):
-        """Fresh high-importance memory should NOT be transitioned."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path)
-        scheduler.run_now()
-        conn = sqlite3.connect(self.db_path)
-        row = conn.execute("SELECT lifecycle_state FROM memories WHERE id=2").fetchone()
-        conn.close()
-        assert row[0] == "active"
-
-    def test_scheduler_thread_is_daemon(self):
-        """Scheduler thread should be daemonic (doesn't prevent exit)."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path, interval_seconds=3600)
-        scheduler.start()
-        assert scheduler._timer is not None
-        assert scheduler._timer.daemon is True
-        scheduler.stop()
-
-    def test_start_and_stop(self):
-        """Scheduler can be started and stopped."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path, interval_seconds=3600)
-        scheduler.start()
-        assert scheduler.is_running is True
-        scheduler.stop()
-        assert scheduler.is_running is False
-
-    def test_configurable_interval(self):
-        """Scheduler interval is configurable."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path, interval_seconds=7200)
-        assert scheduler.interval_seconds == 7200
-
-    def test_result_structure(self):
-        """run_now returns properly structured result."""
-        from lifecycle.lifecycle_scheduler import LifecycleScheduler
-        scheduler = LifecycleScheduler(self.db_path)
-        result = scheduler.run_now()
-        assert "evaluation" in result
-        assert "enforcement" in result
-        assert "timestamp" in result
-        assert "recommendations" in result["evaluation"]
-        assert "transitioned" in result["evaluation"]