v4.1: Add gentle memory decay (1%/day) and pruning (30 days stale)

mnemo.py

@@ -402,6 +402,11 @@ class TieredMemoryManager:
     EVICTION_THRESHOLD = 0.2
     LOOP_MERGE_THRESHOLD = 0.8
     
+    # Memory decay settings (gentle)
+    MEMORY_DECAY_RATE = 0.01   # 1% quality decay per day for unused memories
+    MEMORY_PRUNE_THRESHOLD = 0.15  # Prune memories below this quality
+    MEMORY_STALE_DAYS = 30     # Consider memory stale after this many days unused
+    
     def __init__(self, tuner: SelfTuner):
         self.tuner = tuner
         
@@ -413,7 +418,9 @@ class TieredMemoryManager:
         self.stats = {
             "promotions": 0,
             "demotions": 0,
-            "evictions": 0
+            "evictions": 0,
+            "memories_decayed": 0,
+            "memories_pruned": 0
         }
     
     def add_to_tier(self, memory: Memory, tier: MemoryTier):
@@ -540,6 +547,59 @@ class TieredMemoryManager:
         """Get all memories across tiers"""
         return {**self.semantic_memory, **self.working_memory}
     
+    def decay_memories(self) -> int:
+        """
+        Apply gentle quality decay to unused semantic memories.
+        Memories that are accessed stay fresh; unused ones gradually decay.
+        Returns number of memories affected.
+        """
+        now = time.time()
+        affected = 0
+        
+        for memory in self.semantic_memory.values():
+            # Calculate days since last access
+            days_unused = (now - memory.last_accessed) / 86400  # seconds per day
+            
+            if days_unused > 1:  # Only decay if unused for >1 day
+                # Gentle decay: quality *= (1 - decay_rate * days_unused)
+                # Capped to prevent instant destruction
+                decay_factor = min(days_unused * self.MEMORY_DECAY_RATE, 0.1)
+                memory.quality_score *= (1 - decay_factor)
+                affected += 1
+        
+        return affected
+    
+    def prune_stale_memories(self) -> Tuple[int, List[str]]:
+        """
+        Remove memories that have decayed below threshold.
+        Returns (count_pruned, list_of_pruned_ids).
+        """
+        now = time.time()
+        to_prune = []
+        
+        for mem_id, memory in self.semantic_memory.items():
+            days_unused = (now - memory.last_accessed) / 86400
+            
+            # Prune if: quality too low AND unused for too long
+            if (memory.quality_score < self.MEMORY_PRUNE_THRESHOLD and 
+                days_unused > self.MEMORY_STALE_DAYS):
+                to_prune.append(mem_id)
+        
+        # Remove pruned memories
+        pruned_ids = []
+        for mem_id in to_prune:
+            del self.semantic_memory[mem_id]
+            pruned_ids.append(mem_id)
+        
+        return len(pruned_ids), pruned_ids
+    
+    def refresh_memory(self, memory_id: str):
+        """Mark a memory as freshly accessed (resets decay)"""
+        if memory_id in self.semantic_memory:
+            self.semantic_memory[memory_id].last_accessed = time.time()
+        elif memory_id in self.working_memory:
+            self.working_memory[memory_id].last_accessed = time.time()
+    
     def get_tier_stats(self) -> Dict:
         """Get tier statistics"""
         return {
@@ -709,6 +769,30 @@ class NeuralLinkManager:
         
         return len(to_prune)
     
+    def remove_links_for_memory(self, memory_id: str) -> int:
+        """Remove all links connected to a memory (when memory is pruned)"""
+        to_remove = []
+        
+        # Find all links involving this memory
+        for link_id, link in self.links.items():
+            if link.source_id == memory_id or link.target_id == memory_id:
+                to_remove.append(link_id)
+        
+        # Remove them
+        for link_id in to_remove:
+            link = self.links.pop(link_id)
+            self.outgoing[link.source_id].discard(link_id)
+            self.incoming[link.target_id].discard(link_id)
+            self.stats["links_pruned"] += 1
+        
+        # Clean up empty entries
+        if memory_id in self.outgoing:
+            del self.outgoing[memory_id]
+        if memory_id in self.incoming:
+            del self.incoming[memory_id]
+        
+        return len(to_remove)
+    
     def get_stats(self) -> Dict:
         return {
             "total_links": len(self.links),
@@ -1047,13 +1131,27 @@ class Mnemo:
         self.link_manager.decay_links()
         
         # Prune weak links
-        pruned = self.link_manager.prune_weak_links()
+        links_pruned = self.link_manager.prune_weak_links()
+        
+        # Decay memory quality (gentle)
+        memories_decayed = self.memory_manager.decay_memories()
+        self.memory_manager.stats["memories_decayed"] += memories_decayed
+        
+        # Prune stale memories
+        memories_pruned, pruned_ids = self.memory_manager.prune_stale_memories()
+        self.memory_manager.stats["memories_pruned"] += memories_pruned
+        
+        # Clean up links to pruned memories
+        for mem_id in pruned_ids:
+            self.link_manager.remove_links_for_memory(mem_id)
         
         # Auto-tune parameters
         adjustments = self.tuner.auto_tune()
         
         return {
-            "links_pruned": pruned,
+            "links_pruned": links_pruned,
+            "memories_decayed": memories_decayed,
+            "memories_pruned": memories_pruned,
             "parameter_adjustments": adjustments
         }