spatial-memory-mcp 1.6.1__py3-none-any.whl → 1.7.0__py3-none-any.whl

spatial_memory/__init__.py

@@ -1,6 +1,6 @@
 """Spatial Memory MCP Server - Vector-based semantic memory for LLMs."""
 
-__version__ = "1.6.1"
+__version__ = "1.7.0"
 __author__ = "arman-tech"
 
 # Re-export core components for convenience

spatial_memory/__main__.py

@@ -44,7 +44,7 @@ def run_migrate(args: argparse.Namespace) -> int:
         format="%(levelname)s: %(message)s",
     )
 
-    print(f"Spatial Memory Migration Tool")
+    print("Spatial Memory Migration Tool")
     print(f"Target schema version: {CURRENT_SCHEMA_VERSION}")
     print(f"Database path: {settings.memory_path}")
     print()
@@ -109,7 +109,7 @@ def run_migrate(args: argparse.Namespace) -> int:
                 return 1
 
             if result.migrations_applied:
-                print(f"\nRolled back migrations:")
+                print("\nRolled back migrations:")
                 for v in result.migrations_applied:
                     print(f"  - {v}")
                 print(f"\nCurrent version: {result.current_version}")
@@ -204,7 +204,7 @@ def main() -> NoReturn:
     )
 
     # Server command (default)
-    server_parser = subparsers.add_parser(
+    subparsers.add_parser(
         "serve",
         help="Start the MCP server (default if no command given)",
     )

spatial_memory/adapters/lancedb_repository.py

@@ -606,6 +606,8 @@ class LanceDBMemoryRepository:
             tags=record.get("tags", []),
             importance=record["importance"],
             created_at=record["created_at"],
+            last_accessed=record.get("last_accessed"),
+            access_count=record.get("access_count", 0),
             metadata=record.get("metadata", {}),
             vector=vector,
         )

spatial_memory/config.py

@@ -47,7 +47,7 @@ class Settings(BaseSettings):
     )
     embedding_backend: str = Field(
         default="auto",
-        description="Embedding backend: 'auto' (ONNX if available, else PyTorch), 'onnx', or 'pytorch'",
+        description="Embedding backend: 'auto', 'onnx', or 'pytorch'",
     )
 
     # OpenAI (optional)
@@ -593,6 +593,43 @@ class Settings(BaseSettings):
         description="Maximum queue depth when backpressure is enabled",
     )
 
+    # =========================================================================
+    # v1.6.3: Auto-Decay Settings
+    # =========================================================================
+
+    auto_decay_enabled: bool = Field(
+        default=True,
+        description="Enable automatic decay calculation during recall operations",
+    )
+    auto_decay_persist_enabled: bool = Field(
+        default=True,
+        description="Persist decay updates to database (disable for read-only scenarios)",
+    )
+    auto_decay_persist_batch_size: int = Field(
+        default=100,
+        ge=10,
+        le=1000,
+        description="Batch size for persisting decay updates to database",
+    )
+    auto_decay_persist_flush_interval_seconds: float = Field(
+        default=5.0,
+        ge=1.0,
+        le=60.0,
+        description="Interval between background flush operations for decay updates",
+    )
+    auto_decay_min_change_threshold: float = Field(
+        default=0.01,
+        ge=0.001,
+        le=0.1,
+        description="Minimum importance change to trigger database persistence (1% default)",
+    )
+    auto_decay_max_queue_size: int = Field(
+        default=10000,
+        ge=1000,
+        le=100000,
+        description="Maximum queue size for pending decay updates (backpressure control)",
+    )
+
     model_config = {
         "env_prefix": "SPATIAL_MEMORY_",
         "env_file": ".env",

spatial_memory/core/__init__.py

@@ -11,7 +11,6 @@ from spatial_memory.core.db_indexes import IndexManager
 from spatial_memory.core.db_search import SearchManager
 from spatial_memory.core.db_versioning import VersionManager
 from spatial_memory.core.embeddings import EmbeddingService
-from spatial_memory.core.rate_limiter import RateLimiter
 from spatial_memory.core.errors import (
     ClusteringError,
     ConfigurationError,
@@ -45,7 +44,7 @@ from spatial_memory.core.models import (
     VisualizationEdge,
     VisualizationNode,
 )
-from spatial_memory.core.utils import to_aware_utc, to_naive_utc, utc_now, utc_now_naive
+from spatial_memory.core.rate_limiter import RateLimiter
 from spatial_memory.core.tracing import (
     RequestContext,
     TimingContext,
@@ -55,6 +54,7 @@ from spatial_memory.core.tracing import (
     request_context,
     set_context,
 )
+from spatial_memory.core.utils import to_aware_utc, to_naive_utc, utc_now, utc_now_naive
 
 __all__ = [
     # Errors - Base

spatial_memory/core/consolidation_strategies.py

@@ -26,7 +26,6 @@ from spatial_memory.core.lifecycle_ops import (
 from spatial_memory.core.models import Memory, MemorySource
 
 if TYPE_CHECKING:
-    import numpy as np
 
     from spatial_memory.ports.repositories import (
         EmbeddingServiceProtocol,

spatial_memory/core/database.py

@@ -14,7 +14,6 @@ from __future__ import annotations
 
 import json
 import logging
-import math
 import threading
 import time
 import uuid
@@ -30,8 +29,8 @@ import lancedb.index
 import numpy as np
 import pyarrow as pa
 import pyarrow.parquet as pq
-
-from filelock import FileLock, Timeout as FileLockTimeout
+from filelock import FileLock
+from filelock import Timeout as FileLockTimeout
 
 from spatial_memory.core.connection_pool import ConnectionPool
 from spatial_memory.core.db_idempotency import IdempotencyManager, IdempotencyRecord
@@ -47,8 +46,12 @@ from spatial_memory.core.errors import (
     StorageError,
     ValidationError,
 )
-from spatial_memory.core.filesystem import detect_filesystem_type, get_filesystem_warning_message, is_network_filesystem
-from spatial_memory.core.utils import to_aware_utc, utc_now
+from spatial_memory.core.filesystem import (
+    detect_filesystem_type,
+    get_filesystem_warning_message,
+    is_network_filesystem,
+)
+from spatial_memory.core.utils import utc_now
 
 # Import centralized validation functions
 from spatial_memory.core.validation import (
@@ -221,7 +224,7 @@ def with_write_lock(func: F) -> F:
     Uses RLock to allow nested calls (e.g., bulk_import -> insert_batch).
     """
     @wraps(func)
-    def wrapper(self: "Database", *args: Any, **kwargs: Any) -> Any:
+    def wrapper(self: Database, *args: Any, **kwargs: Any) -> Any:
         with self._write_lock:
             return func(self, *args, **kwargs)
     return cast(F, wrapper)
@@ -235,7 +238,7 @@ def with_stale_connection_recovery(func: F) -> F:
     reconnects, and retries the operation once.
     """
     @wraps(func)
-    def wrapper(self: "Database", *args: Any, **kwargs: Any) -> Any:
+    def wrapper(self: Database, *args: Any, **kwargs: Any) -> Any:
         try:
             return func(self, *args, **kwargs)
         except Exception as e:
@@ -372,7 +375,7 @@ class ProcessLockManager:
             self._set_depth(depth - 1)
             return False  # Still holding
 
-    def __enter__(self) -> "ProcessLockManager":
+    def __enter__(self) -> ProcessLockManager:
         """Enter context manager - acquire lock."""
         self.acquire()
         return self
@@ -397,7 +400,7 @@ def with_process_lock(func: F) -> F:
             ...
     """
     @wraps(func)
-    def wrapper(self: "Database", *args: Any, **kwargs: Any) -> Any:
+    def wrapper(self: Database, *args: Any, **kwargs: Any) -> Any:
         if self._process_lock is None:
             return func(self, *args, **kwargs)
         with self._process_lock:
@@ -1705,7 +1708,7 @@ class Database:
         old_namespace = _validate_namespace(old_namespace)
         new_namespace = _validate_namespace(new_namespace)
         safe_old = _sanitize_string(old_namespace)
-        safe_new = _sanitize_string(new_namespace)
+        _sanitize_string(new_namespace)  # Validate but don't store unused result
 
         try:
             # Check if source namespace exists
@@ -1835,7 +1838,7 @@ class Database:
             if not memory_ids:
                 return None
 
-            safe_namespace = _sanitize_string(target_namespace)
+            _sanitize_string(target_namespace)  # Validate namespace
             now = utc_now()
 
             # Process in batches for large rollbacks

spatial_memory/core/db_indexes.py

@@ -380,7 +380,8 @@ class IndexManager:
             index_type = "IVF_FLAT"
             sample_rate = max(16, count // 4)  # Lower sample rate for small data
         else:
-            index_type = self._db.index_type if self._db.index_type in ("IVF_PQ", "IVF_FLAT") else "IVF_PQ"
+            valid_types = ("IVF_PQ", "IVF_FLAT")
+            index_type = self._db.index_type if self._db.index_type in valid_types else "IVF_PQ"
 
         # Ensure num_partitions < num_vectors for KMeans clustering
         if num_partitions >= count:

spatial_memory/core/db_migrations.py

@@ -24,7 +24,6 @@ Usage:
 
 from __future__ import annotations
 
-import json
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field

spatial_memory/core/db_search.py

@@ -18,6 +18,8 @@ import numpy as np
 from spatial_memory.core.errors import StorageError, ValidationError
 from spatial_memory.core.validation import (
     sanitize_string as _sanitize_string,
+)
+from spatial_memory.core.validation import (
     validate_namespace as _validate_namespace,
 )
 
@@ -312,7 +314,8 @@ class SearchManager:
                 ])
 
             # Execute search and get results
-            # LanceDB returns results with _query_index to identify which query each result belongs to
+            # LanceDB returns results with _query_index to identify which query
+            # each result belongs to
             search = search.limit(limit_per_query)
             results_df = search.to_pandas()
 

spatial_memory/core/embeddings.py

@@ -265,13 +265,13 @@ class EmbeddingService:
                     backend="onnx",
                 )
                 logger.info(
-                    f"Using ONNX Runtime backend (2-3x faster inference)"
+                    "Using ONNX Runtime backend (2-3x faster inference)"
                 )
             else:
                 # Use default PyTorch backend
                 self._model = SentenceTransformer(self.model_name)
                 logger.info(
-                    f"Using PyTorch backend"
+                    "Using PyTorch backend"
                 )
 
             self._dimensions = self._model.get_sentence_embedding_dimension()

spatial_memory/core/file_security.py

@@ -23,7 +23,6 @@ import re
 import stat
 import urllib.parse
 from collections.abc import Sequence
-from io import BufferedReader
 from pathlib import Path
 from typing import BinaryIO
 

spatial_memory/core/models.py

@@ -52,6 +52,15 @@ class MemoryResult(BaseModel):
     tags: list[str] = Field(default_factory=list)
     importance: float
     created_at: datetime
+    last_accessed: datetime | None = Field(
+        default=None,
+        description="When the memory was last accessed (for auto-decay)",
+    )
+    access_count: int = Field(
+        default=0,
+        ge=0,
+        description="Number of times the memory has been accessed (for auto-decay)",
+    )
     metadata: dict[str, Any] = Field(default_factory=dict)
     vector: list[float] | None = Field(
         default=None,
@@ -582,6 +591,8 @@ class HybridMemoryMatch:
     vector_score: float | None = None
     fts_score: float | None = None
     combined_score: float = 0.0
+    last_accessed: datetime | None = None  # For auto-decay
+    access_count: int = 0  # For auto-decay
 
 
 @dataclass
@@ -626,3 +637,23 @@ class ExportImportConfig:
     csv_include_vectors: bool = False
     max_export_records: int = 0  # 0 = unlimited
     max_import_records: int = 100_000  # Maximum records per import
+
+
+@dataclass
+class AutoDecayConfig:
+    """Configuration for automatic decay during recall operations.
+
+    Auto-decay calculates effective importance in real-time during searches,
+    re-ranking results based on time-decayed importance. Updates can optionally
+    be persisted to the database in the background.
+    """
+
+    enabled: bool = True
+    persist_enabled: bool = True
+    persist_batch_size: int = 100
+    persist_flush_interval_seconds: float = 5.0
+    min_change_threshold: float = 0.01  # Only persist changes > 1%
+    max_queue_size: int = 10000
+    half_life_days: float = 30.0
+    min_importance_floor: float = 0.1
+    access_weight: float = 0.3  # Weight of access count in slowing decay

spatial_memory/core/response_types.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 from typing import Any, TypedDict
 
+from typing_extensions import NotRequired
 
 # =============================================================================
 # Nested TypedDicts (shared across multiple responses)
@@ -30,6 +31,7 @@ class MemoryResultDict(TypedDict):
     importance: float
     created_at: str  # ISO 8601 format
     metadata: dict[str, Any]
+    effective_importance: NotRequired[float]  # Time-decayed importance (auto-decay)
 
 
 class MemoryReferenceDict(TypedDict):
@@ -231,6 +233,7 @@ class HybridMemoryDict(TypedDict):
     metadata: dict[str, Any]
     vector_score: float | None
     fts_score: float | None
+    effective_importance: NotRequired[float]  # Time-decayed importance (auto-decay)
 
 
 # =============================================================================

spatial_memory/factory.py

@@ -22,7 +22,9 @@ from spatial_memory.config import Settings
 from spatial_memory.core.cache import ResponseCache
 from spatial_memory.core.database import Database
 from spatial_memory.core.embeddings import EmbeddingService
+from spatial_memory.core.models import AutoDecayConfig
 from spatial_memory.core.rate_limiter import AgentAwareRateLimiter, RateLimiter
+from spatial_memory.services.decay_manager import DecayManager
 from spatial_memory.services.export_import import ExportImportConfig, ExportImportService
 from spatial_memory.services.lifecycle import LifecycleConfig, LifecycleService
 from spatial_memory.services.memory import MemoryService
@@ -55,6 +57,7 @@ class ServiceContainer:
         lifecycle: Lifecycle service for decay/reinforce/consolidate.
         utility: Utility service for stats/namespaces/hybrid search.
         export_import: Export/import service for data portability.
+        decay_manager: Automatic decay manager for real-time importance decay.
         rate_limiter: Simple rate limiter (if per-agent disabled).
         agent_rate_limiter: Per-agent rate limiter (if enabled).
         cache: Response cache for read operations.
@@ -71,6 +74,7 @@ class ServiceContainer:
     lifecycle: LifecycleService
     utility: UtilityService
     export_import: ExportImportService
+    decay_manager: DecayManager | None
     rate_limiter: RateLimiter | None
     agent_rate_limiter: AgentAwareRateLimiter | None
     cache: ResponseCache | None
@@ -351,6 +355,35 @@ class ServiceFactory:
             self._settings.response_cache_regions_ttl,
         )
 
+    def create_decay_manager(
+        self,
+        repository: MemoryRepositoryProtocol,
+    ) -> DecayManager | None:
+        """Create the decay manager based on settings.
+
+        Args:
+            repository: Repository for persisting decay updates.
+
+        Returns:
+            DecayManager if auto-decay is enabled, None otherwise.
+        """
+        if not self._settings.auto_decay_enabled:
+            return None
+
+        config = AutoDecayConfig(
+            enabled=self._settings.auto_decay_enabled,
+            persist_enabled=self._settings.auto_decay_persist_enabled,
+            persist_batch_size=self._settings.auto_decay_persist_batch_size,
+            persist_flush_interval_seconds=self._settings.auto_decay_persist_flush_interval_seconds,
+            min_change_threshold=self._settings.auto_decay_min_change_threshold,
+            max_queue_size=self._settings.auto_decay_max_queue_size,
+            half_life_days=self._settings.decay_default_half_life_days,
+            min_importance_floor=self._settings.decay_min_importance_floor,
+            access_weight=0.3,  # Default access weight
+        )
+
+        return DecayManager(repository=repository, config=config)
+
     def create_all(self) -> ServiceContainer:
         """Create all services with proper dependency wiring.
 
@@ -383,6 +416,9 @@ class ServiceFactory:
         utility = self.create_utility_service(repository, embeddings)
         export_import = self.create_export_import_service(repository, embeddings)
 
+        # Create decay manager
+        decay_manager = self.create_decay_manager(repository)
+
         # Create rate limiter
         rate_limiter, agent_rate_limiter, per_agent_enabled = self.create_rate_limiter()
 
@@ -398,6 +434,7 @@ class ServiceFactory:
             lifecycle=lifecycle,
             utility=utility,
             export_import=export_import,
+            decay_manager=decay_manager,
             rate_limiter=rate_limiter,
             agent_rate_limiter=agent_rate_limiter,
             cache=cache,

spatial_memory/ports/repositories.py

@@ -12,7 +12,6 @@ from typing import Any, Protocol
 
 import numpy as np
 
-from spatial_memory.core.errors import NamespaceNotFoundError
 from spatial_memory.core.models import Memory, MemoryResult
 
 

spatial_memory/server.py

@@ -25,7 +25,6 @@ from mcp.types import TextContent, Tool
 
 from spatial_memory import __version__
 from spatial_memory.config import ConfigurationError, get_settings, validate_startup
-from spatial_memory.factory import ServiceFactory
 from spatial_memory.core.database import (
     clear_connection_cache,
     set_connection_pool_max_size,
@@ -46,6 +45,10 @@ from spatial_memory.core.errors import (
     SpatialMemoryError,
     ValidationError,
 )
+from spatial_memory.core.health import HealthChecker
+from spatial_memory.core.logging import configure_logging
+from spatial_memory.core.metrics import is_available as metrics_available
+from spatial_memory.core.metrics import record_request
 from spatial_memory.core.response_types import (
     ConsolidateResponse,
     DecayResponse,
@@ -71,15 +74,12 @@ from spatial_memory.core.response_types import (
     VisualizeResponse,
     WanderResponse,
 )
-from spatial_memory.core.health import HealthChecker
-from spatial_memory.core.logging import configure_logging
-from spatial_memory.core.metrics import is_available as metrics_available
-from spatial_memory.core.metrics import record_request
 from spatial_memory.core.tracing import (
     RequestContext,
     TimingContext,
     request_context,
 )
+from spatial_memory.factory import ServiceFactory
 from spatial_memory.tools import TOOLS
 
 if TYPE_CHECKING:
@@ -198,6 +198,12 @@ class SpatialMemoryServer:
         self._cache = services.cache
         self._regions_cache_ttl = services.regions_cache_ttl
 
+        # Auto-decay manager
+        self._decay_manager = services.decay_manager
+        if self._decay_manager is not None:
+            self._decay_manager.start()
+            logger.info("Auto-decay manager started")
+
         # ThreadPoolExecutor for non-blocking embedding operations
         self._executor = ThreadPoolExecutor(
             max_workers=2,
@@ -430,21 +436,50 @@ class SpatialMemoryServer:
             namespace=arguments.get("namespace"),
             min_similarity=arguments.get("min_similarity", 0.0),
         )
+
+        # Convert to dict list for potential decay processing
+        memories_list = [
+            {
+                "id": m.id,
+                "content": m.content,
+                "similarity": m.similarity,
+                "namespace": m.namespace,
+                "tags": m.tags,
+                "importance": m.importance,
+                "created_at": m.created_at.isoformat(),
+                "metadata": m.metadata,
+                "last_accessed": m.last_accessed,
+                "access_count": m.access_count,
+            }
+            for m in recall_result.memories
+        ]
+
+        # Apply auto-decay if enabled (adds effective_importance, re-ranks)
+        if self._decay_manager is not None and self._decay_manager.enabled:
+            memories_list = self._decay_manager.apply_decay_to_results(
+                memories_list, rerank=True
+            )
+
+        # Build response - include effective_importance if present
+        response_memories = []
+        for m in memories_list:
+            mem_dict: dict[str, Any] = {
+                "id": m["id"],
+                "content": m["content"],
+                "similarity": m["similarity"],
+                "namespace": m["namespace"],
+                "tags": m["tags"],
+                "importance": m["importance"],
+                "created_at": m["created_at"],
+                "metadata": m["metadata"],
+            }
+            if "effective_importance" in m:
+                mem_dict["effective_importance"] = m["effective_importance"]
+            response_memories.append(mem_dict)
+
         return {
-            "memories": [
-                {
-                    "id": m.id,
-                    "content": m.content,
-                    "similarity": m.similarity,
-                    "namespace": m.namespace,
-                    "tags": m.tags,
-                    "importance": m.importance,
-                    "created_at": m.created_at.isoformat(),
-                    "metadata": m.metadata,
-                }
-                for m in recall_result.memories
-            ],
-            "total": recall_result.total,
+            "memories": response_memories,  # type: ignore[typeddict-item]
+            "total": len(response_memories),
         }
 
     def _handle_nearby(self, arguments: dict[str, Any]) -> NearbyResponse:
@@ -926,27 +961,56 @@ class SpatialMemoryServer:
             namespace=arguments.get("namespace"),
             min_similarity=arguments.get("min_similarity", 0.0),
         )
+
+        # Convert to dict list for potential decay processing
+        memories_list = [
+            {
+                "id": m.id,
+                "content": m.content,
+                "similarity": m.similarity,
+                "namespace": m.namespace,
+                "tags": m.tags,
+                "importance": m.importance,
+                "created_at": m.created_at.isoformat() if m.created_at else None,
+                "metadata": m.metadata,
+                "vector_score": m.vector_score,
+                "fts_score": m.fts_score,
+                "last_accessed": m.last_accessed,
+                "access_count": m.access_count,
+            }
+            for m in hybrid_result.memories
+        ]
+
+        # Apply auto-decay if enabled (adds effective_importance, re-ranks)
+        if self._decay_manager is not None and self._decay_manager.enabled:
+            memories_list = self._decay_manager.apply_decay_to_results(
+                memories_list, rerank=True
+            )
+
+        # Build response - include effective_importance if present
+        response_memories = []
+        for m in memories_list:
+            mem_dict: dict[str, Any] = {
+                "id": m["id"],
+                "content": m["content"],
+                "similarity": m["similarity"],
+                "namespace": m["namespace"],
+                "tags": m["tags"],
+                "importance": m["importance"],
+                "created_at": m["created_at"],
+                "metadata": m["metadata"],
+                "vector_score": m.get("vector_score"),
+                "fts_score": m.get("fts_score"),
+            }
+            if "effective_importance" in m:
+                mem_dict["effective_importance"] = m["effective_importance"]
+            response_memories.append(mem_dict)
+
         return {
             "query": hybrid_result.query,
             "alpha": hybrid_result.alpha,
-            "memories": [
-                {
-                    "id": m.id,
-                    "content": m.content,
-                    "similarity": m.similarity,
-                    "namespace": m.namespace,
-                    "tags": m.tags,
-                    "importance": m.importance,
-                    "created_at": (
-                        m.created_at.isoformat() if m.created_at else None
-                    ),
-                    "metadata": m.metadata,
-                    "vector_score": m.vector_score,
-                    "fts_score": m.fts_score,
-                }
-                for m in hybrid_result.memories
-            ],
-            "total": hybrid_result.total,
+            "memories": response_memories,  # type: ignore[typeddict-item]
+            "total": len(response_memories),
             "search_type": hybrid_result.search_type,
         }
 
@@ -999,10 +1063,12 @@ class SpatialMemoryServer:
         """
         return '''## Spatial Memory System
 
-You have access to a persistent semantic memory system. Use it proactively to build cumulative knowledge across sessions.
+You have access to a persistent semantic memory system. Use it proactively to
+build cumulative knowledge across sessions.
 
 ### Session Start
-At conversation start, call `recall` with the user's apparent task/context to load relevant memories. Present insights naturally:
+At conversation start, call `recall` with the user's apparent task/context to
+load relevant memories. Present insights naturally:
 - Good: "Based on previous work, you decided to use PostgreSQL because..."
 - Bad: "The database returned: [{id: '...', content: '...'}]"
 
@@ -1013,11 +1079,13 @@ After these events, ask briefly "Save this? y/n" (minimal friction):
 - **Patterns**: "This pattern works...", "The trick is...", "Always do X when..."
 - **Discoveries**: "I found that...", "Important:...", "TIL..."
 
-Do NOT ask for trivial information. Only prompt for insights that would help future sessions.
+Do NOT ask for trivial information. Only prompt for insights that would help
+future sessions.
 
 ### Saving Memories
 When user confirms, save with:
-- **Detailed content**: Include full context, reasoning, and specifics. Future agents need complete information.
+- **Detailed content**: Include full context, reasoning, and specifics. Future
+  agents need complete information.
 - **Contextual namespace**: Use project name, or categories like "decisions", "errors", "patterns"
 - **Descriptive tags**: Technologies, concepts, error types involved
 - **High importance (0.8-1.0)**: For decisions and critical fixes
@@ -1054,6 +1122,10 @@ Then use `extract` to automatically capture important information.
 
     def close(self) -> None:
         """Clean up resources."""
+        # Stop the decay manager (flushes pending updates)
+        if self._decay_manager is not None:
+            self._decay_manager.stop()
+
         # Shutdown the thread pool executor
         if hasattr(self, "_executor"):
             self._executor.shutdown(wait=False)