loki-mode 6.66.0 → 6.67.0

package/dashboard/server.py

@@ -2056,9 +2056,10 @@ async def get_episode(episode_id: str):
     ep_dir = loki_dir / "memory" / "episodic"
     if not ep_dir.exists():
         raise HTTPException(status_code=404, detail="Episode not found")
+    real_loki = os.path.realpath(str(loki_dir))
     for f in ep_dir.glob("*.json"):
         resolved = os.path.realpath(f)
-        if not resolved.startswith(os.path.realpath(str(loki_dir))):
+        if not resolved.startswith(real_loki + os.sep) and resolved != real_loki:
             raise HTTPException(status_code=403, detail="Access denied")
         try:
             data = json.loads(f.read_text())
@@ -2144,9 +2145,10 @@ async def get_skill(skill_id: str):
     skills_dir = loki_dir / "memory" / "skills"
     if not skills_dir.exists():
         raise HTTPException(status_code=404, detail="Skill not found")
+    real_loki = os.path.realpath(str(loki_dir))
     for f in skills_dir.glob("*.json"):
         resolved = os.path.realpath(f)
-        if not resolved.startswith(os.path.realpath(str(loki_dir))):
+        if not resolved.startswith(real_loki + os.sep) and resolved != real_loki:
             raise HTTPException(status_code=403, detail="Access denied")
         try:
             data = json.loads(f.read_text())
@@ -3547,8 +3549,8 @@ async def get_checkpoint(checkpoint_id: str):
 
     try:
         return json.loads(metadata_file.read_text())
-    except (json.JSONDecodeError, IOError) as e:
-        raise HTTPException(status_code=500, detail=f"Failed to read checkpoint: {e}")
+    except (json.JSONDecodeError, IOError):
+        raise HTTPException(status_code=500, detail="Failed to read checkpoint data")
 
 
 @app.post("/api/checkpoints", status_code=201, dependencies=[Depends(auth.require_scope("control"))])
@@ -3816,8 +3818,20 @@ async def get_logs(lines: int = 100, token: Optional[dict] = Depends(auth.get_cu
                 file_mtime = datetime.fromtimestamp(log_file.stat().st_mtime, tz=timezone.utc).strftime(
                     "%Y-%m-%dT%H:%M:%S"
                 )
-                content = _safe_read_text(log_file)
-                for raw_line in content.strip().split("\n")[-lines:]:
+                # Read only the tail to avoid loading huge files into memory
+                tail_lines = []
+                try:
+                    with open(log_file, "rb") as lf:
+                        # Seek from end to find enough lines
+                        lf.seek(0, 2)
+                        file_size = lf.tell()
+                        # Read at most 1MB from the end (plenty for any reasonable lines count)
+                        read_size = min(file_size, 1024 * 1024)
+                        lf.seek(max(0, file_size - read_size))
+                        tail_lines = lf.read().decode("utf-8", errors="replace").strip().split("\n")[-lines:]
+                except (OSError, UnicodeDecodeError):
+                    tail_lines = []
+                for raw_line in tail_lines:
                     timestamp = ""
                     level = "info"
                     message = raw_line

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:** v6.66.0
+**Version:** v6.67.0
 
 ---
 

package/events/bus.py

@@ -6,6 +6,7 @@ This enables CLI, API, VS Code, and MCP to communicate without shared memory.
 """
 
 import json
+import logging
 import os
 import time
 import uuid
@@ -17,6 +18,8 @@ from pathlib import Path
 from typing import Generator, List, Optional, Callable
 import threading
 
+logger = logging.getLogger(__name__)
+
 
 class EventType(str, Enum):
     """Event types that can be emitted."""
@@ -374,7 +377,12 @@ class EventBus:
                             try:
                                 callback(event)
                             except Exception:
-                                pass  # Don't let one callback break others
+                                logger.warning(
+                                    "Event callback %s failed for event %s",
+                                    getattr(callback, "__name__", callback),
+                                    event.type,
+                                    exc_info=True,
+                                )
                     self.mark_processed(event)
                 time.sleep(poll_interval)
 

package/events/emit.sh

@@ -41,9 +41,9 @@ else
     TIMESTAMP=$(date -u +"%Y-%m-%dT%H:%M:%S.000Z")
 fi
 
-# JSON escape helper: handles \, ", and control characters
+# JSON escape helper: handles \, ", and control characters including newlines
 json_escape() {
-    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g; s/\r/\\r/g' | awk '{if(NR>1) printf "\\n"; printf "%s", $0}'
+    printf '%s' "$1" | sed 's/\\/\\\\/g; s/"/\\"/g; s/\t/\\t/g; s/\r/\\r/g; s//\\b/g; s//\\f/g' | awk '{if(NR>1) printf "\\n"; printf "%s", $0}'
 }
 
 # Build payload JSON

package/mcp/__init__.py

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

package/memory/namespace.py

@@ -140,20 +140,20 @@ class NamespaceManager:
         lock_path = Path(str(path) + ".lock")
         lock_path.parent.mkdir(parents=True, exist_ok=True)
 
-        lock_file = None
+        lock_file = open(lock_path, "w")
         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:
+            try:
+                yield
+            finally:
                 fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
-                lock_file.close()
-                try:
-                    os.remove(lock_path)
-                except OSError:
-                    pass
+        finally:
+            lock_file.close()
+            try:
+                os.remove(lock_path)
+            except OSError:
+                pass
 
     def _load_registry(self) -> Dict[str, Any]:
         """Load the namespace registry with shared file lock."""
@@ -163,7 +163,10 @@ class NamespaceManager:
 
         with self._file_lock(registry_path, exclusive=False):
             with open(registry_path, "r") as f:
-                return json.load(f)
+                try:
+                    return json.load(f)
+                except json.JSONDecodeError:
+                    return {"version": "1.0.0", "namespaces": {}}
 
     def _save_registry(self, registry: Dict[str, Any]) -> None:
         """Save the namespace registry with exclusive file lock."""

package/memory/schemas.py

@@ -782,3 +782,158 @@ class ProceduralSkill:
     def add_error_fix(self, error: str, fix: str) -> None:
         """Add a common error and its fix."""
         self.common_errors.append(ErrorFix(error=error, fix=fix))
+
+
+# -----------------------------------------------------------------------------
+# Healing Memory Types (v6.67.0)
+# Inspired by Amazon AGI Lab's failure-first learning approach.
+# These types store friction points, failure modes, and institutional knowledge
+# discovered during legacy system healing operations.
+# -----------------------------------------------------------------------------
+
+
+@dataclass
+class FrictionPoint:
+    """
+    A friction point discovered during codebase archaeology.
+
+    Friction points are behaviors that appear to be bugs but may actually
+    be undocumented business rules. They must be classified before removal.
+
+    Attributes:
+        id: Unique identifier (e.g., "friction-001")
+        location: File path and line number (e.g., "src/billing/invoice.py:234")
+        behavior: Description of the observed behavior
+        classification: business_rule, true_bug, or unknown
+        evidence: Evidence supporting the classification
+        discovered_by: How this was discovered (archaeology_scan, manual, test_failure)
+        timestamp: When discovered
+        safe_to_remove: Whether it's safe to remove this friction
+    """
+    id: str
+    location: str
+    behavior: str
+    classification: str = "unknown"  # business_rule | true_bug | unknown
+    evidence: str = ""
+    discovered_by: str = "archaeology_scan"
+    timestamp: Optional[datetime] = None
+    safe_to_remove: bool = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        result = {
+            "id": self.id,
+            "location": self.location,
+            "behavior": self.behavior,
+            "classification": self.classification,
+            "evidence": self.evidence,
+            "discovered_by": self.discovered_by,
+            "safe_to_remove": self.safe_to_remove,
+        }
+        if self.timestamp:
+            result["timestamp"] = _to_utc_isoformat(self.timestamp)
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FrictionPoint":
+        """Create from dictionary."""
+        timestamp = None
+        if data.get("timestamp"):
+            ts = data["timestamp"]
+            if isinstance(ts, str):
+                timestamp = _parse_utc_datetime(ts)
+        return cls(
+            id=data.get("id", ""),
+            location=data.get("location", ""),
+            behavior=data.get("behavior", ""),
+            classification=data.get("classification", "unknown"),
+            evidence=data.get("evidence", ""),
+            discovered_by=data.get("discovered_by", "archaeology_scan"),
+            timestamp=timestamp,
+            safe_to_remove=data.get("safe_to_remove", False),
+        )
+
+    def validate(self) -> List[str]:
+        """Validate the friction point."""
+        errors = []
+        if not self.id:
+            errors.append("FrictionPoint.id is required")
+        if not self.location:
+            errors.append("FrictionPoint.location is required")
+        if not self.behavior:
+            errors.append("FrictionPoint.behavior is required")
+        if self.classification not in ("business_rule", "true_bug", "unknown"):
+            errors.append("FrictionPoint.classification must be business_rule, true_bug, or unknown")
+        return errors
+
+
+@dataclass
+class FailureMode:
+    """
+    A failure mode discovered during healing operations.
+
+    Failure-first learning: each failure teaches about the system's
+    real behavior. Failures are stored and used to build understanding.
+
+    Attributes:
+        mode_id: Unique identifier
+        trigger: What causes the failure
+        behavior: What happens when it fails
+        recovery: How the system currently recovers
+        is_intentional: Whether the failure is by design
+        component: System component where failure occurs
+        characterization_test_id: Test that reproduces this mode
+    """
+    mode_id: str
+    trigger: str
+    behavior: str
+    recovery: str = ""
+    is_intentional: bool = False
+    component: str = ""
+    characterization_test_id: str = ""
+    timestamp: Optional[datetime] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for JSON serialization."""
+        result = {
+            "mode_id": self.mode_id,
+            "trigger": self.trigger,
+            "behavior": self.behavior,
+            "recovery": self.recovery,
+            "is_intentional": self.is_intentional,
+            "component": self.component,
+            "characterization_test_id": self.characterization_test_id,
+        }
+        if self.timestamp:
+            result["timestamp"] = _to_utc_isoformat(self.timestamp)
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "FailureMode":
+        """Create from dictionary."""
+        timestamp = None
+        if data.get("timestamp"):
+            ts = data["timestamp"]
+            if isinstance(ts, str):
+                timestamp = _parse_utc_datetime(ts)
+        return cls(
+            mode_id=data.get("mode_id", ""),
+            trigger=data.get("trigger", ""),
+            behavior=data.get("behavior", ""),
+            recovery=data.get("recovery", ""),
+            is_intentional=data.get("is_intentional", False),
+            component=data.get("component", ""),
+            characterization_test_id=data.get("characterization_test_id", ""),
+            timestamp=timestamp,
+        )
+
+    def validate(self) -> List[str]:
+        """Validate the failure mode."""
+        errors = []
+        if not self.mode_id:
+            errors.append("FailureMode.mode_id is required")
+        if not self.trigger:
+            errors.append("FailureMode.trigger is required")
+        if not self.behavior:
+            errors.append("FailureMode.behavior is required")
+        return errors

package/memory/storage.py

@@ -512,7 +512,13 @@ class MemoryStorage:
             # Load existing patterns
             if patterns_path.exists():
                 with open(patterns_path, "r") as f:
-                    patterns_file = json.load(f)
+                    try:
+                        patterns_file = json.load(f)
+                    except json.JSONDecodeError:
+                        patterns_file = {
+                            "version": self.VERSION,
+                            "patterns": []
+                        }
             else:
                 patterns_file = {
                     "version": self.VERSION,
@@ -625,7 +631,10 @@ class MemoryStorage:
                 return False
 
             with open(patterns_path, "r") as f:
-                patterns_file = json.load(f)
+                try:
+                    patterns_file = json.load(f)
+                except json.JSONDecodeError:
+                    return False
 
             # Find and update pattern
             found = False
@@ -835,7 +844,15 @@ class MemoryStorage:
         with self._file_lock(timeline_path, exclusive=True):
             if timeline_path.exists():
                 with open(timeline_path, "r") as f:
-                    timeline = json.load(f)
+                    try:
+                        timeline = json.load(f)
+                    except json.JSONDecodeError:
+                        timeline = {
+                            "version": self.VERSION,
+                            "recent_actions": [],
+                            "key_decisions": [],
+                            "active_context": {}
+                        }
             else:
                 timeline = {
                     "version": self.VERSION,
@@ -908,7 +925,15 @@ class MemoryStorage:
         with self._file_lock(timeline_path, exclusive=True):
             if timeline_path.exists():
                 with open(timeline_path, "r") as f:
-                    timeline = json.load(f)
+                    try:
+                        timeline = json.load(f)
+                    except json.JSONDecodeError:
+                        timeline = {
+                            "version": self.VERSION,
+                            "recent_actions": [],
+                            "key_decisions": [],
+                            "active_context": {}
+                        }
             else:
                 timeline = {
                     "version": self.VERSION,

package/package.json

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