loki-mode 5.32.2 → 5.33.0

package/memory/engine.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import json
 import os
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union
 
@@ -118,7 +118,7 @@ class MemoryEngine:
                 "index.json",
                 {
                     "version": "1.0",
-                    "last_updated": datetime.now().isoformat(),
+                    "last_updated": datetime.now(timezone.utc).isoformat(),
                     "topics": [],
                     "total_memories": 0,
                     "total_tokens_available": 0,
@@ -131,7 +131,7 @@ class MemoryEngine:
                 "timeline.json",
                 {
                     "version": "1.0",
-                    "last_updated": datetime.now().isoformat(),
+                    "last_updated": datetime.now(timezone.utc).isoformat(),
                     "recent_actions": [],
                     "key_decisions": [],
                     "active_context": {
@@ -195,7 +195,7 @@ class MemoryEngine:
         Returns:
             Number of memories removed
         """
-        cutoff = datetime.now() - timedelta(days=days)
+        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
         removed_count = 0
 
         # Get referenced episode IDs from semantic patterns
@@ -215,7 +215,7 @@ class MemoryEngine:
 
             # Parse date from directory name (e.g., 2026-01-06)
             try:
-                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d")
+                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d").replace(tzinfo=timezone.utc)
             except ValueError:
                 continue
 
@@ -251,7 +251,7 @@ class MemoryEngine:
         """
         # Determine storage path based on timestamp
         trace_dict = trace.to_dict() if hasattr(trace, "to_dict") else trace.__dict__.copy()
-        timestamp = trace_dict.get("timestamp", datetime.now().isoformat())
+        timestamp = trace_dict.get("timestamp", datetime.now(timezone.utc).isoformat())
 
         if isinstance(timestamp, str):
             date_str = timestamp[:10]  # Extract YYYY-MM-DD
@@ -436,7 +436,7 @@ class MemoryEngine:
         for pattern in patterns_data["patterns"]:
             if pattern.get("id") == pattern_id:
                 pattern["usage_count"] = pattern.get("usage_count", 0) + 1
-                pattern["last_used"] = datetime.now().isoformat()
+                pattern["last_used"] = datetime.now(timezone.utc).isoformat()
                 break
 
         self.storage.write_json("semantic/patterns.json", patterns_data)
@@ -618,7 +618,7 @@ class MemoryEngine:
         Returns:
             List of memories within the time range
         """
-        until = until or datetime.now()
+        until = until or datetime.now(timezone.utc)
         results: List[Dict[str, Any]] = []
 
         episodic_path = Path(self.base_path) / "episodic"
@@ -630,7 +630,7 @@ class MemoryEngine:
                 continue
 
             try:
-                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d")
+                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d").replace(tzinfo=timezone.utc)
             except ValueError:
                 continue
 
@@ -745,7 +745,7 @@ class MemoryEngine:
             "index.json",
             {
                 "version": "1.0",
-                "last_updated": datetime.now().isoformat(),
+                "last_updated": datetime.now(timezone.utc).isoformat(),
                 "topics": list(topics.values()),
                 "total_memories": total_memories,
                 "total_tokens_available": total_tokens,
@@ -774,7 +774,7 @@ class MemoryEngine:
         # Create action summary
         context = episode.get("context", {})
         action_entry = {
-            "timestamp": episode.get("timestamp", datetime.now().isoformat()),
+            "timestamp": episode.get("timestamp", datetime.now(timezone.utc).isoformat()),
             "action": context.get("goal", "Task completed")[:100],
             "outcome": episode.get("outcome", "unknown"),
             "topic_id": context.get("phase", "general"),
@@ -783,7 +783,7 @@ class MemoryEngine:
         # Add to recent actions (keep last 50)
         timeline["recent_actions"].insert(0, action_entry)
         timeline["recent_actions"] = timeline["recent_actions"][:50]
-        timeline["last_updated"] = datetime.now().isoformat()
+        timeline["last_updated"] = datetime.now(timezone.utc).isoformat()
 
         self.storage.write_json("timeline.json", timeline)
 
@@ -802,7 +802,7 @@ class MemoryEngine:
         topic_found = False
         for topic in index["topics"]:
             if topic.get("id") == category:
-                topic["last_accessed"] = datetime.now().isoformat()
+                topic["last_accessed"] = datetime.now(timezone.utc).isoformat()
                 topic["relevance_score"] = max(
                     topic.get("relevance_score", 0.5),
                     pattern.get("confidence", 0.5),
@@ -815,11 +815,11 @@ class MemoryEngine:
                 "id": category,
                 "summary": f"Patterns for {category}",
                 "relevance_score": pattern.get("confidence", 0.5),
-                "last_accessed": datetime.now().isoformat(),
+                "last_accessed": datetime.now(timezone.utc).isoformat(),
                 "token_count": len(json.dumps(pattern)) // 4,
             })
 
-        index["last_updated"] = datetime.now().isoformat()
+        index["last_updated"] = datetime.now(timezone.utc).isoformat()
         index["total_memories"] = index.get("total_memories", 0) + 1
 
         self.storage.write_json("index.json", index)
@@ -851,10 +851,14 @@ class MemoryEngine:
             if timestamp_str.endswith("Z"):
                 timestamp_str = timestamp_str[:-1]
             timestamp = datetime.fromisoformat(timestamp_str)
+            if timestamp.tzinfo is None:
+                timestamp = timestamp.replace(tzinfo=timezone.utc)
         elif isinstance(timestamp_str, datetime):
             timestamp = timestamp_str
+            if timestamp.tzinfo is None:
+                timestamp = timestamp.replace(tzinfo=timezone.utc)
         else:
-            timestamp = datetime.now()
+            timestamp = datetime.now(timezone.utc)
 
         # Extract phase and goal from context dict
         context = data.get("context", {})
@@ -904,8 +908,12 @@ class MemoryEngine:
                 if last_used_raw.endswith("Z"):
                     last_used_raw = last_used_raw[:-1]
                 last_used = datetime.fromisoformat(last_used_raw)
+                if last_used.tzinfo is None:
+                    last_used = last_used.replace(tzinfo=timezone.utc)
             elif isinstance(last_used_raw, datetime):
                 last_used = last_used_raw
+                if last_used.tzinfo is None:
+                    last_used = last_used.replace(tzinfo=timezone.utc)
 
         # Convert links dicts to Link objects
         links_raw = data.get("links", [])

package/memory/retrieval.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import json
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Protocol, Tuple, Union, TYPE_CHECKING
 
@@ -746,7 +746,7 @@ class MemoryRetrieval:
         Returns:
             List of memories within the time range
         """
-        until = until or datetime.now()
+        until = until or datetime.now(timezone.utc)
         results: List[Dict[str, Any]] = []
 
         # Search episodic memories by date directory (via storage layer)
@@ -756,7 +756,7 @@ class MemoryRetrieval:
                 continue
 
             try:
-                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d")
+                dir_date = datetime.strptime(date_dir.name, "%Y-%m-%d").replace(tzinfo=timezone.utc)
             except ValueError:
                 continue
 
@@ -938,7 +938,7 @@ class MemoryRetrieval:
         Returns:
             Results with recency boost applied
         """
-        now = datetime.now()
+        now = datetime.now(timezone.utc)
 
         for result in results:
             timestamp = result.get("timestamp") or result.get("last_used")
@@ -1281,25 +1281,34 @@ class MemoryRetrieval:
         """
         Save all vector indices to disk.
         """
-        vectors_path = self.base_path / "vectors"
-        vectors_path.mkdir(parents=True, exist_ok=True)
+        if hasattr(self.storage, 'ensure_directory'):
+            self.storage.ensure_directory("vectors")
 
         for name, index in self.vector_indices.items():
-            index_path = vectors_path / f"{name}_index"
-            index.save(str(index_path))
+            # Resolve path through storage to respect namespace isolation
+            if hasattr(self.storage, '_resolve_path'):
+                index_path = self.storage._resolve_path(f"vectors/{name}_index")
+            else:
+                index_path = str(self.base_path / "vectors" / f"{name}_index")
+            index.save(index_path)
 
     def load_indices(self) -> None:
         """
         Load all vector indices from disk.
         """
-        vectors_path = self.base_path / "vectors"
-        if not vectors_path.exists():
+        vectors_files = self.storage.list_files("vectors", "*")
+        if not vectors_files:
             return
 
         for name, index in self.vector_indices.items():
-            index_path = vectors_path / f"{name}_index"
-            if index_path.exists():
-                index.load(str(index_path))
+            if hasattr(self.storage, '_resolve_path'):
+                index_path = self.storage._resolve_path(f"vectors/{name}_index")
+            else:
+                index_path = str(self.base_path / "vectors" / f"{name}_index")
+            # Check if the npz file exists (VectorIndex.load expects base path without extension)
+            import os
+            if os.path.exists(f"{index_path}.npz"):
+                index.load(index_path)
 
     # -------------------------------------------------------------------------
     # Private Helper Methods
@@ -1453,16 +1462,16 @@ class MemoryRetrieval:
             return
 
         index = self.vector_indices["episodic"]
-        episodic_path = self.base_path / "episodic"
-
-        if not episodic_path.exists():
-            return
+        date_dirs = self.storage.list_files("episodic", "*")
 
-        for date_dir in episodic_path.iterdir():
+        for date_dir in date_dirs:
             if not date_dir.is_dir():
                 continue
 
-            for episode_file in date_dir.glob("*.json"):
+            episode_files = self.storage.list_files(
+                f"episodic/{date_dir.name}", "*.json"
+            )
+            for episode_file in episode_files:
                 if episode_file.name == "index.json":
                     continue
 

package/memory/storage.py

@@ -118,6 +118,23 @@ class MemoryStorage:
         for directory in directories:
             directory.mkdir(parents=True, exist_ok=True)
 
+        # Clean up stale lock files from previous crashed processes
+        self._cleanup_stale_locks()
+
+    def _cleanup_stale_locks(self) -> None:
+        """Remove stale .lock files older than 5 minutes (safe with concurrent processes)."""
+        try:
+            stale_cutoff = datetime.now(timezone.utc) - timedelta(minutes=5)
+            for lock_file in self.base_path.rglob("*.lock"):
+                try:
+                    mtime = datetime.fromtimestamp(lock_file.stat().st_mtime, tz=timezone.utc)
+                    if mtime < stale_cutoff:
+                        lock_file.unlink()
+                except OSError:
+                    pass
+        except OSError:
+            pass
+
     def _ensure_index(self) -> None:
         """Initialize index.json if it doesn't exist."""
         index_path = self.base_path / "index.json"
@@ -383,10 +400,19 @@ class MemoryStorage:
                 if file_path.exists():
                     with self._file_lock(file_path, exclusive=True):
                         file_path.unlink()
-                    # Clean up lock file
+                    # Clean up lock file (safety net in case _file_lock missed it)
                     lock_path = file_path.with_suffix(".json.lock")
-                    if lock_path.exists():
-                        lock_path.unlink()
+                    try:
+                        if lock_path.exists():
+                            lock_path.unlink()
+                    except OSError:
+                        pass
+                    # Clean up any remaining lock files before checking if dir is empty
+                    for stale_lock in date_dir.glob("*.lock"):
+                        try:
+                            stale_lock.unlink()
+                        except OSError:
+                            pass
                     # Clean up empty date directory
                     if not any(date_dir.iterdir()):
                         date_dir.rmdir()

package/memory/vector_index.py

@@ -348,15 +348,15 @@ class VectorIndex:
         Normalize copies of all vectors for cosine similarity search.
 
         This is called automatically before search operations.
-        Uses copies to avoid corrupting the original stored embeddings.
+        Uses explicit copies to avoid corrupting the original stored embeddings.
         """
         self._normalized_embeddings = []
         for embedding in self.embeddings:
-            norm = np.linalg.norm(embedding)
+            vec_copy = embedding.copy()
+            norm = np.linalg.norm(vec_copy)
             if norm > 0:
-                self._normalized_embeddings.append(embedding / norm)
-            else:
-                self._normalized_embeddings.append(embedding.copy())
+                vec_copy = vec_copy / norm
+            self._normalized_embeddings.append(vec_copy)
         self._normalized = True
 
     def _cosine_similarity(self, a: np.ndarray, b: np.ndarray) -> float:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.32.2",
+  "version": "5.33.0",
   "description": "Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "claude",