loki-mode 5.58.0 → 5.58.2

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v5.58.0
+**Version:** v5.58.2
 
 ---
 

package/events/bus.ts

@@ -69,6 +69,49 @@ function getTimestamp(): string {
   return new Date().toISOString();
 }
 
+/**
+ * Write a file with an exclusive lockfile to prevent concurrent corruption.
+ * Creates a .lock file, writes data, then removes the lock.
+ */
+function writeFileWithLock(filepath: string, data: string): void {
+  const lockfile = filepath + ".lock";
+  let fd: number | null = null;
+  try {
+    // Acquire lock by creating lockfile exclusively (fails if already exists)
+    fd = fs.openSync(lockfile, "wx");
+    fs.closeSync(fd);
+    fd = null;
+    // Write the actual data
+    fs.writeFileSync(filepath, data);
+  } catch (e: unknown) {
+    // If lock acquisition failed (file exists), retry once after brief delay
+    if (e instanceof Error && "code" in e && (e as NodeJS.ErrnoException).code === "EEXIST") {
+      // Another process holds the lock; wait briefly and retry
+      const start = Date.now();
+      while (fs.existsSync(lockfile) && Date.now() - start < 1000) {
+        // Busy-wait up to 1 second
+      }
+      try {
+        fd = fs.openSync(lockfile, "wx");
+        fs.closeSync(fd);
+        fd = null;
+        fs.writeFileSync(filepath, data);
+      } catch {
+        // Fall back to unlocked write
+        fs.writeFileSync(filepath, data);
+      }
+    } else {
+      throw e;
+    }
+  } finally {
+    try {
+      fs.unlinkSync(lockfile);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
 /**
  * File-based Event Bus
  */
@@ -132,7 +175,7 @@ export class EventBus {
     }
 
     try {
-      fs.writeFileSync(
+      writeFileWithLock(
         this.processedFile,
         JSON.stringify({ ids: Array.from(this.processedIds) })
       );
@@ -158,7 +201,7 @@ export class EventBus {
     const filepath = path.join(this.pendingDir, filename);
 
     try {
-      fs.writeFileSync(filepath, JSON.stringify(fullEvent, null, 2));
+      writeFileWithLock(filepath, JSON.stringify(fullEvent, null, 2));
     } catch (e) {
       throw new Error(`Failed to emit event: ${e}`);
     }

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '5.58.0'
+__version__ = '5.58.2'

package/mcp/server.py

@@ -248,6 +248,7 @@ logger = logging.getLogger('loki-mcp')
 
 # Track tool call start times for duration calculation (per-tool stack)
 _tool_call_start_times: Dict[str, List[float]] = {}
+_tool_call_times_lock = threading.Lock()
 
 
 def _emit_tool_event_async(tool_name: str, action: str, **kwargs) -> None:
@@ -261,15 +262,17 @@ def _emit_tool_event_async(tool_name: str, action: str, **kwargs) -> None:
     """
     import time
 
-    # Track timing for learning signals using a per-tool-name stack
+    # Track timing for learning signals using a per-tool-name stack (thread-safe)
     if action == 'start':
-        _tool_call_start_times.setdefault(tool_name, []).append(time.time())
+        with _tool_call_times_lock:
+            _tool_call_start_times.setdefault(tool_name, []).append(time.time())
     elif action == 'complete':
         # Pop the most recent start time for this tool
         start_time = None
-        times = _tool_call_start_times.get(tool_name)
-        if times:
-            start_time = times.pop()
+        with _tool_call_times_lock:
+            times = _tool_call_start_times.get(tool_name)
+            if times:
+                start_time = times.pop()
         if start_time:
             execution_time_ms = int((time.time() - start_time) * 1000)
             _emit_learning_signal_async(
@@ -674,8 +677,10 @@ async def loki_task_queue_add(
             else:
                 queue = {"tasks": [], "version": "1.0"}
 
-        # Create new task
-        task_id = f"task-{len(queue['tasks']) + 1:04d}"
+        # Create new task with monotonic counter to avoid ID collisions after deletions
+        next_id = queue.get("_next_id", len(queue['tasks']) + 1)
+        task_id = f"task-{next_id:04d}"
+        queue["_next_id"] = next_id + 1
         task = {
             "id": task_id,
             "title": title,
@@ -1064,7 +1069,7 @@ async def loki_project_status() -> str:
                 status["tasks"] = {
                     "total": len(tasks),
                     "pending": sum(1 for t in tasks if t.get("status") == "pending"),
-                    "in_progress": sum(1 for t in tasks if t.get("status") == "in-progress"),
+                    "in_progress": sum(1 for t in tasks if t.get("status") == "in_progress"),
                     "completed": sum(1 for t in tasks if t.get("status") == "completed"),
                 }
 
@@ -1098,8 +1103,8 @@ async def loki_agent_metrics() -> str:
         if os.path.isdir(metrics_dir):
             for fname in os.listdir(metrics_dir):
                 if fname.endswith('.json'):
-                    fpath = os.path.join(metrics_dir, fname)
-                    with open(fpath, 'r') as f:
+                    fpath = safe_path_join('.loki', 'metrics', 'efficiency', fname)
+                    with safe_open(fpath, 'r') as f:
                         metrics["agents"].append(json.load(f))
 
         # Read token economics
@@ -1139,8 +1144,8 @@ async def loki_checkpoint_restore(checkpoint_id: str = "") -> str:
         checkpoints = []
         for fname in sorted(os.listdir(cp_dir)):
             if fname.endswith('.json'):
-                fpath = os.path.join(cp_dir, fname)
-                with open(fpath, 'r') as f:
+                fpath = safe_path_join('.loki', 'state', 'checkpoints', fname)
+                with safe_open(fpath, 'r') as f:
                     cp = json.load(f)
                     cp["id"] = fname.replace('.json', '')
                     checkpoints.append(cp)

package/mcp/tools.py

@@ -100,9 +100,11 @@ def create_task(
 ) -> Dict[str, Any]:
     """Create a new task dictionary."""
     queue = load_task_queue()
-    task_id = f"task-{len(queue['tasks']) + 1:04d}"
+    next_id = queue.get("_next_id", len(queue['tasks']) + 1)
+    task_id = f"task-{next_id:04d}"
+    queue["_next_id"] = next_id + 1
 
-    return {
+    task = {
         "id": task_id,
         "title": title,
         "description": description,
@@ -112,6 +114,11 @@ def create_task(
         "created_at": datetime.now(timezone.utc).isoformat()
     }
 
+    # Persist _next_id so it survives across calls
+    save_task_queue(queue)
+
+    return task
+
 
 def filter_tasks_by_status(tasks: List[Dict], status: str) -> List[Dict]:
     """Filter tasks by their status."""

package/memory/consolidation.py

@@ -540,11 +540,14 @@ class ConsolidationPipeline:
         if not failed_episodes:
             return []
 
-        # Group failures by error type
+        # Group failures by error type (use set to avoid duplicate episodes)
         error_groups: Dict[str, List[EpisodeTrace]] = defaultdict(list)
+        seen_episodes: Dict[str, set] = defaultdict(set)
         for episode in failed_episodes:
-            for error in episode.errors_encountered:
-                error_groups[error.error_type].append(episode)
+            for err_entry in episode.errors_encountered:
+                if episode.id not in seen_episodes[err_entry.error_type]:
+                    error_groups[err_entry.error_type].append(episode)
+                    seen_episodes[err_entry.error_type].add(episode.id)
 
         anti_patterns = []
 
@@ -564,9 +567,9 @@ class ConsolidationPipeline:
                     )
 
                 # Collect resolutions
-                for error in episode.errors_encountered:
-                    if error.error_type == error_type and error.resolution:
-                        resolutions.append(error.resolution)
+                for err_entry in episode.errors_encountered:
+                    if err_entry.error_type == error_type and err_entry.resolution:
+                        resolutions.append(err_entry.resolution)
 
             # Create anti-pattern
             incorrect_approach = self._summarize_actions(pre_error_actions)

package/memory/engine.py

@@ -14,6 +14,7 @@ from typing import Any, Callable, Dict, List, Optional, Union
 from .schemas import (
     ActionEntry,
     ErrorEntry,
+    ErrorFix,
     EpisodeTrace,
     Link,
     ProceduralSkill,
@@ -939,13 +940,18 @@ class MemoryEngine:
 
     def _dict_to_skill(self, data: Dict[str, Any]) -> ProceduralSkill:
         """Convert dictionary to ProceduralSkill."""
+        raw_errors = data.get("common_errors", [])
+        common_errors = [
+            ErrorFix.from_dict(e) if isinstance(e, dict) else e
+            for e in raw_errors
+        ]
         return ProceduralSkill(
             id=data.get("id", ""),
             name=data.get("name", ""),
             description=data.get("description", ""),
             prerequisites=data.get("prerequisites", []),
             steps=data.get("steps", []),
-            common_errors=data.get("common_errors", []),
+            common_errors=common_errors,
             exit_criteria=data.get("exit_criteria", []),
         )
 

package/memory/namespace.py

@@ -15,14 +15,16 @@ Based on competitor analysis (claude-mem project isolation patterns).
 
 from __future__ import annotations
 
+import fcntl
 import json
 import os
 import re
 import subprocess
+from contextlib import contextmanager
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set
+from typing import Any, Dict, Generator, List, Optional, Set
 
 
 # Default namespace when none can be detected
@@ -65,7 +67,12 @@ class NamespaceInfo:
             "metadata": self.metadata,
         }
         if self.created_at:
-            result["created_at"] = self.created_at.isoformat() + "Z"
+            iso = self.created_at.isoformat()
+            if iso.endswith("+00:00"):
+                iso = iso[:-6] + "Z"
+            elif not iso.endswith("Z"):
+                iso = iso + "Z"
+            result["created_at"] = iso
         return result
 
     @classmethod
@@ -127,21 +134,44 @@ class NamespaceManager:
             with open(registry_path, "w") as f:
                 json.dump(initial_registry, f, indent=2)
 
+    @contextmanager
+    def _file_lock(self, path: Path, exclusive: bool = True) -> Generator[None, None, None]:
+        """Acquire a file lock for safe concurrent access."""
+        lock_path = Path(str(path) + ".lock")
+        lock_path.parent.mkdir(parents=True, exist_ok=True)
+
+        lock_file = None
+        try:
+            lock_file = open(lock_path, "w")
+            lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
+            fcntl.flock(lock_file.fileno(), lock_type)
+            yield
+        finally:
+            if lock_file is not None:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+                lock_file.close()
+                try:
+                    os.remove(lock_path)
+                except OSError:
+                    pass
+
     def _load_registry(self) -> Dict[str, Any]:
-        """Load the namespace registry."""
+        """Load the namespace registry with shared file lock."""
         registry_path = self.base_path / self.REGISTRY_FILE
         if not registry_path.exists():
             return {"version": "1.0.0", "namespaces": {}}
 
-        with open(registry_path, "r") as f:
-            return json.load(f)
+        with self._file_lock(registry_path, exclusive=False):
+            with open(registry_path, "r") as f:
+                return json.load(f)
 
     def _save_registry(self, registry: Dict[str, Any]) -> None:
-        """Save the namespace registry."""
+        """Save the namespace registry with exclusive file lock."""
         registry_path = self.base_path / self.REGISTRY_FILE
         self.base_path.mkdir(parents=True, exist_ok=True)
-        with open(registry_path, "w") as f:
-            json.dump(registry, f, indent=2)
+        with self._file_lock(registry_path, exclusive=True):
+            with open(registry_path, "w") as f:
+                json.dump(registry, f, indent=2)
 
     # -------------------------------------------------------------------------
     # Auto-Detection

package/memory/retrieval.py

@@ -1379,9 +1379,10 @@ class MemoryRetrieval:
                 score += sum(0.5 for kw in keywords if kw in phase)
 
                 if score > 0:
-                    data["_score"] = score
-                    data["_source"] = "episodic"
-                    results.append(data)
+                    data_copy = dict(data)
+                    data_copy["_score"] = score
+                    data_copy["_source"] = "episodic"
+                    results.append(data_copy)
 
         return results
 
@@ -1407,9 +1408,10 @@ class MemoryRetrieval:
             score *= confidence
 
             if score > 0:
-                pattern["_score"] = score
-                pattern["_source"] = "semantic"
-                results.append(pattern)
+                pattern_copy = dict(pattern)
+                pattern_copy["_score"] = score
+                pattern_copy["_source"] = "semantic"
+                results.append(pattern_copy)
 
         return results
 
@@ -1435,9 +1437,10 @@ class MemoryRetrieval:
             score += sum(0.5 for kw in keywords if kw in steps_text)
 
             if score > 0:
-                data["_score"] = score
-                data["_source"] = "skills"
-                results.append(data)
+                data_copy = dict(data)
+                data_copy["_score"] = score
+                data_copy["_source"] = "skills"
+                results.append(data_copy)
 
         return results
 
@@ -1459,9 +1462,10 @@ class MemoryRetrieval:
             score += sum(1 for kw in keywords if kw in prevention)
 
             if score > 0:
-                anti["_score"] = score
-                anti["_source"] = "anti_patterns"
-                results.append(anti)
+                anti_copy = dict(anti)
+                anti_copy["_score"] = score
+                anti_copy["_source"] = "anti_patterns"
+                results.append(anti_copy)
 
         return results
 

package/memory/schemas.py

@@ -17,6 +17,35 @@ from datetime import datetime, timezone
 from typing import Optional, List, Dict, Any
 
 
+def _to_utc_isoformat(dt: datetime) -> str:
+    """Convert datetime to UTC ISO 8601 string with Z suffix.
+
+    Handles both timezone-aware and timezone-naive datetimes,
+    and avoids double-suffixing if already has timezone info.
+    """
+    iso = dt.isoformat()
+    # If already has timezone offset like +00:00, replace with Z
+    if iso.endswith("+00:00"):
+        return iso[:-6] + "Z"
+    # If no timezone info, append Z (assumed UTC)
+    if not iso.endswith("Z") and "+" not in iso and iso.count("-") <= 2:
+        return iso + "Z"
+    return iso
+
+
+def _parse_utc_datetime(s: str) -> datetime:
+    """Parse an ISO 8601 string into a timezone-aware UTC datetime.
+
+    Handles trailing 'Z', '+00:00', and naive strings (assumed UTC).
+    """
+    if s.endswith("Z"):
+        s = s[:-1]
+    dt = datetime.fromisoformat(s)
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=timezone.utc)
+    return dt
+
+
 # -----------------------------------------------------------------------------
 # Supporting Types
 # -----------------------------------------------------------------------------
@@ -311,7 +340,7 @@ class EpisodeTrace:
         result = {
             "id": self.id,
             "task_id": self.task_id,
-            "timestamp": self.timestamp.isoformat() + "Z",
+            "timestamp": _to_utc_isoformat(self.timestamp),
             "duration_seconds": self.duration_seconds,
             "agent": self.agent,
             "context": {
@@ -331,7 +360,7 @@ class EpisodeTrace:
             "access_count": self.access_count,
         }
         if self.last_accessed:
-            result["last_accessed"] = self.last_accessed.isoformat() + "Z"
+            result["last_accessed"] = _to_utc_isoformat(self.last_accessed)
         return result
 
     @classmethod
@@ -339,24 +368,25 @@ class EpisodeTrace:
         """Create from dictionary."""
         context = data.get("context", {})
         timestamp_str = data.get("timestamp", "")
-        if isinstance(timestamp_str, str):
-            # Handle ISO format with Z suffix
-            if timestamp_str.endswith("Z"):
-                timestamp_str = timestamp_str[:-1]
-            timestamp = datetime.fromisoformat(timestamp_str)
-        else:
+        if isinstance(timestamp_str, str) and timestamp_str:
+            timestamp = _parse_utc_datetime(timestamp_str)
+        elif isinstance(timestamp_str, datetime):
             timestamp = timestamp_str
+            if timestamp.tzinfo is None:
+                timestamp = timestamp.replace(tzinfo=timezone.utc)
+        else:
+            timestamp = datetime.now(timezone.utc)
 
         # Parse last_accessed datetime
         last_accessed = None
         last_accessed_str = data.get("last_accessed")
         if last_accessed_str:
             if isinstance(last_accessed_str, str):
-                if last_accessed_str.endswith("Z"):
-                    last_accessed_str = last_accessed_str[:-1]
-                last_accessed = datetime.fromisoformat(last_accessed_str)
+                last_accessed = _parse_utc_datetime(last_accessed_str)
             else:
                 last_accessed = last_accessed_str
+                if hasattr(last_accessed, 'tzinfo') and last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
 
         return cls(
             id=data.get("id", ""),
@@ -506,9 +536,9 @@ class SemanticPattern:
             "access_count": self.access_count,
         }
         if self.last_used:
-            result["last_used"] = self.last_used.isoformat() + "Z"
+            result["last_used"] = _to_utc_isoformat(self.last_used)
         if self.last_accessed:
-            result["last_accessed"] = self.last_accessed.isoformat() + "Z"
+            result["last_accessed"] = _to_utc_isoformat(self.last_accessed)
         return result
 
     @classmethod
@@ -518,17 +548,21 @@ class SemanticPattern:
         if data.get("last_used"):
             last_used_str = data["last_used"]
             if isinstance(last_used_str, str):
-                if last_used_str.endswith("Z"):
-                    last_used_str = last_used_str[:-1]
-                last_used = datetime.fromisoformat(last_used_str)
+                last_used = _parse_utc_datetime(last_used_str)
+            elif isinstance(last_used_str, datetime):
+                last_used = last_used_str
+                if last_used.tzinfo is None:
+                    last_used = last_used.replace(tzinfo=timezone.utc)
 
         last_accessed = None
         if data.get("last_accessed"):
             last_accessed_str = data["last_accessed"]
             if isinstance(last_accessed_str, str):
-                if last_accessed_str.endswith("Z"):
-                    last_accessed_str = last_accessed_str[:-1]
-                last_accessed = datetime.fromisoformat(last_accessed_str)
+                last_accessed = _parse_utc_datetime(last_accessed_str)
+            elif isinstance(last_accessed_str, datetime):
+                last_accessed = last_accessed_str
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
 
         return cls(
             id=data.get("id", ""),
@@ -661,7 +695,7 @@ class ProceduralSkill:
         if self.example_usage:
             result["example_usage"] = self.example_usage
         if self.last_accessed:
-            result["last_accessed"] = self.last_accessed.isoformat() + "Z"
+            result["last_accessed"] = _to_utc_isoformat(self.last_accessed)
         return result
 
     @classmethod
@@ -671,9 +705,11 @@ class ProceduralSkill:
         if data.get("last_accessed"):
             last_accessed_str = data["last_accessed"]
             if isinstance(last_accessed_str, str):
-                if last_accessed_str.endswith("Z"):
-                    last_accessed_str = last_accessed_str[:-1]
-                last_accessed = datetime.fromisoformat(last_accessed_str)
+                last_accessed = _parse_utc_datetime(last_accessed_str)
+            elif isinstance(last_accessed_str, datetime):
+                last_accessed = last_accessed_str
+                if last_accessed.tzinfo is None:
+                    last_accessed = last_accessed.replace(tzinfo=timezone.utc)
 
         return cls(
             id=data.get("id", ""),

package/memory/storage.py

@@ -303,17 +303,20 @@ class MemoryStorage:
 
         return episode_id
 
-    def load_episode(self, episode_id: str) -> Optional[EpisodeTrace]:
+    def load_episode(self, episode_id: str) -> Optional[dict]:
         """
         Load an episode trace by ID.
 
         Searches across all date directories.
 
+        Note: Returns a raw dict, not an EpisodeTrace object.
+        Callers should convert via EpisodeTrace.from_dict() if needed.
+
         Args:
             episode_id: The episode ID to load
 
         Returns:
-            EpisodeTrace object or None if not found
+            dict or None if not found
         """
         episodic_dir = self.base_path / "episodic"
         if not episodic_dir.exists():
@@ -494,15 +497,18 @@ class MemoryStorage:
 
         return pattern_id
 
-    def load_pattern(self, pattern_id: str) -> Optional[SemanticPattern]:
+    def load_pattern(self, pattern_id: str) -> Optional[dict]:
         """
         Load a semantic pattern by ID.
 
+        Note: Returns a raw dict, not a SemanticPattern object.
+        Callers should convert via SemanticPattern.from_dict() if needed.
+
         Args:
             pattern_id: The pattern ID to load
 
         Returns:
-            SemanticPattern object or None if not found
+            dict or None if not found
         """
         patterns_path = self.base_path / "semantic" / "patterns.json"
         patterns_file = self._load_json(patterns_path)
@@ -646,15 +652,18 @@ class MemoryStorage:
 
         return skill_id
 
-    def load_skill(self, skill_id: str) -> Optional[ProceduralSkill]:
+    def load_skill(self, skill_id: str) -> Optional[dict]:
         """
         Load a procedural skill by ID.
 
+        Note: Returns a raw dict, not a ProceduralSkill object.
+        Callers should convert via ProceduralSkill.from_dict() if needed.
+
         Args:
             skill_id: The skill ID to load
 
         Returns:
-            ProceduralSkill object or None if not found
+            dict or None if not found
         """
         skills_dir = self.base_path / "skills"
         if not skills_dir.exists():

package/memory/vector_index.py

@@ -7,12 +7,18 @@ No FAISS dependency required - uses pure numpy for cosine similarity.
 This module provides efficient vector storage and retrieval for the
 memory system's embedding-based search capabilities.
 """
+from __future__ import annotations
 
 import json
 import os
 from typing import Callable, Dict, List, Optional, Tuple
 
-import numpy as np
+try:
+    import numpy as np
+    NUMPY_AVAILABLE = True
+except ImportError:
+    np = None  # type: ignore
+    NUMPY_AVAILABLE = False
 
 
 class VectorIndex:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "5.58.0",
+  "version": "5.58.2",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",