loki-mode 7.67.0 → 7.69.0

package/mcp/__init__.py

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

package/mcp/server.py

@@ -1358,14 +1358,17 @@ async def loki_start_project(prd_content: str = "", prd_path: str = "") -> str:
             try:
                 resolved = validate_path(prd_path, allowed_dirs=['.'])
             except PathTraversalError as e:
+                _emit_tool_event_async('loki_start_project', 'complete', result_status='error', error=str(e))
                 return json.dumps({"error": str(e)})
             if os.path.exists(resolved) and os.path.isfile(resolved):
                 with open(resolved, 'r', encoding='utf-8') as f:
                     content = f.read()
             else:
+                _emit_tool_event_async('loki_start_project', 'complete', result_status='error', error='PRD file not found')
                 return json.dumps({"error": f"PRD file not found: {prd_path}"})
 
         if not content:
+            _emit_tool_event_async('loki_start_project', 'complete', result_status='error', error='No PRD content or path provided')
             return json.dumps({"error": "No PRD content or path provided"})
 
         # Initialize project state using safe path operations
@@ -1390,6 +1393,7 @@ async def loki_start_project(prd_content: str = "", prd_path: str = "") -> str:
         _emit_tool_event_async('loki_start_project', 'complete', result_status='success')
         return json.dumps({"success": True, **project})
     except PathTraversalError as e:
+        _emit_tool_event_async('loki_start_project', 'complete', result_status='error', error='Access denied')
         return json.dumps({"error": f"Access denied: {e}"})
     except Exception as e:
         logger.error(f"Start project failed: {e}")
@@ -1440,6 +1444,7 @@ async def loki_project_status() -> str:
         _emit_tool_event_async('loki_project_status', 'complete', result_status='success')
         return json.dumps(status, default=str)
     except PathTraversalError:
+        _emit_tool_event_async('loki_project_status', 'complete', result_status='error', error='Access denied')
         return json.dumps({"error": "Access denied"})
     except Exception as e:
         logger.error(f"Project status failed: {e}")
@@ -1478,6 +1483,7 @@ async def loki_agent_metrics() -> str:
         _emit_tool_event_async('loki_agent_metrics', 'complete', result_status='success')
         return json.dumps(metrics, default=str)
     except PathTraversalError:
+        _emit_tool_event_async('loki_agent_metrics', 'complete', result_status='error', error='Access denied')
         return json.dumps({"error": "Access denied"})
     except Exception as e:
         logger.error(f"Agent metrics failed: {e}")
@@ -1500,6 +1506,7 @@ async def loki_checkpoint_restore(checkpoint_id: str = "") -> str:
     try:
         cp_dir = safe_path_join('.loki', 'state', 'checkpoints')
         if not os.path.isdir(cp_dir):
+            _emit_tool_event_async('loki_checkpoint_restore', 'complete', result_status='success')
             return json.dumps({"checkpoints": [], "message": "No checkpoints directory"})
 
         checkpoints = []
@@ -1518,6 +1525,7 @@ async def loki_checkpoint_restore(checkpoint_id: str = "") -> str:
         # Find and restore specific checkpoint
         target = next((c for c in checkpoints if c["id"] == checkpoint_id), None)
         if not target:
+            _emit_tool_event_async('loki_checkpoint_restore', 'complete', result_status='error', error='Checkpoint not found')
             return json.dumps({"error": f"Checkpoint not found: {checkpoint_id}"})
 
         # Write checkpoint state as current state, stripping the injected "id" field
@@ -1529,6 +1537,7 @@ async def loki_checkpoint_restore(checkpoint_id: str = "") -> str:
         _emit_tool_event_async('loki_checkpoint_restore', 'complete', result_status='success')
         return json.dumps({"restored": True, "checkpoint_id": checkpoint_id})
     except PathTraversalError:
+        _emit_tool_event_async('loki_checkpoint_restore', 'complete', result_status='error', error='Access denied')
         return json.dumps({"error": "Access denied"})
     except Exception as e:
         logger.error(f"Checkpoint restore failed: {e}")
@@ -1569,6 +1578,7 @@ async def loki_quality_report() -> str:
         _emit_tool_event_async('loki_quality_report', 'complete', result_status='success')
         return json.dumps(report, default=str)
     except PathTraversalError:
+        _emit_tool_event_async('loki_quality_report', 'complete', result_status='error', error='Access denied')
         return json.dumps({"error": "Access denied"})
     except Exception as e:
         logger.error(f"Quality report failed: {e}")
@@ -2057,6 +2067,7 @@ async def mem_get(
 
         id_list = [i.strip() for i in ids.split(",") if i.strip()]
         if not id_list:
+            _emit_tool_event_async('mem_get', 'complete', result_status='error', error='No IDs provided')
             return json.dumps({"entries": {}, "error": "No IDs provided"})
 
         # Cap at 20 to prevent abuse
@@ -2401,6 +2412,7 @@ async def loki_learnings(limit: int = 50) -> str:
     try:
         path = safe_path_join('.loki', 'state', 'relevant-learnings.json')
         if not os.path.exists(path):
+            _emit_tool_event_async('loki_learnings', 'complete', result_status='success')
             return json.dumps({"version": 1, "learnings": [], "total": 0})
         try:
             with safe_open(path, 'r') as f:

package/memory/consolidation.py

@@ -839,6 +839,20 @@ class ConsolidationPipeline:
         if best_match is None or best_similarity < 0.5:
             return new_pattern
 
+        # Idempotency guard (consolidation-C4): only boost confidence when the
+        # merge actually introduces NEW evidence. consolidate() reloads every
+        # episode in the since-window on each run (storage.list_episodes has no
+        # consolidated-state filter), so re-running over an unchanged episode set
+        # re-extracts identical patterns that re-match this existing pattern. A
+        # flat +0.05 every time would ratchet confidence up artificially with no
+        # new data. Comparing source_episodes (which round-trips through storage)
+        # makes the merge a no-op for confidence when no new source episode is
+        # present, while still rewarding a genuinely new similar episode.
+        new_source_episodes = (
+            set(new_pattern.source_episodes) - set(best_match.source_episodes)
+        )
+        confidence_boost = 0.05 if new_source_episodes else 0.0
+
         # Merge patterns
         merged = SemanticPattern(
             id=best_match.id,
@@ -847,7 +861,7 @@ class ConsolidationPipeline:
             conditions=list(set(best_match.conditions + new_pattern.conditions)),
             correct_approach=best_match.correct_approach or new_pattern.correct_approach,
             incorrect_approach=best_match.incorrect_approach or new_pattern.incorrect_approach,
-            confidence=min(best_match.confidence + 0.05, 0.99),
+            confidence=min(best_match.confidence + confidence_boost, 0.99),
             source_episodes=list(set(best_match.source_episodes + new_pattern.source_episodes)),
             usage_count=best_match.usage_count,
             last_used=best_match.last_used,

package/memory/engine.py

@@ -244,7 +244,11 @@ class MemoryEngine:
         for pattern in patterns_data.get("patterns", []):
             if not isinstance(pattern, dict):
                 continue
-            referenced_ids.update(pattern.get("source_episodes", []))
+            # `or []` guards an explicit null source_episodes (corrupt or
+            # hand-edited record): .get(..., []) returns None on a stored
+            # null, and set.update(None) raises TypeError, crashing the whole
+            # cleanup pass. A null and an empty list are equivalent here.
+            referenced_ids.update(pattern.get("source_episodes") or [])
 
         # Scan episodic directories
         episodic_path = Path(self.base_path) / "episodic"
@@ -376,17 +380,28 @@ class MemoryEngine:
                         "last_accessed": now,
                         "relevance_score": 0.5,
                     })
-                    index["total_memories"] = index.get("total_memories", 0) + 1
+                    # total_memories counts memories (episodes), not topics, to
+                    # match the canonical rebuild_index semantics
+                    # (total_memories += 1 per episode at line ~860). Previously
+                    # this only incremented when a NEW topic was created, so N
+                    # episodes sharing one phase reported total_memories=1 until
+                    # the user ran rebuild_index, which then jumped it to N
+                    # (two functions in this file disagreeing on the same field,
+                    # surfaced by get_stats). Increment per distinct episode.
+                    if episode_id:
+                        index["total_memories"] = index.get("total_memories", 0) + 1
                 else:
                     # Only count a given episode once. On resume/checkpoint the same
                     # trace id can be re-saved; without this guard episode_count,
-                    # total_cost_usd, and total_tokens would inflate on every re-save
-                    # even though episode_ids is already de-duplicated.
+                    # total_cost_usd, total_tokens, and total_memories would inflate
+                    # on every re-save even though episode_ids is already
+                    # de-duplicated.
                     if episode_id and episode_id not in found.get("episode_ids", []):
                         found.setdefault("episode_ids", []).append(episode_id)
                         found["episode_count"] = found.get("episode_count", 0) + 1
                         found["total_cost_usd"] = float(found.get("total_cost_usd", 0) or 0) + cost
                         found["total_tokens"] = int(found.get("total_tokens", 0) or 0) + tokens
+                        index["total_memories"] = index.get("total_memories", 0) + 1
                     merged = set(found.get("files_touched", []) or []) | set(files[:20])
                     found["files_touched"] = sorted(merged)[:50]
                     found["last_accessed"] = now
@@ -878,7 +893,12 @@ class MemoryEngine:
                             }
 
                         topics[phase]["token_count"] += tokens
-                        if data.get("timestamp", "") > topics[phase].get("last_accessed", ""):
+                        # `or ""` on BOTH sides: an episode with a missing or
+                        # explicit-null timestamp leaves last_accessed=None (set
+                        # from data.get("timestamp") above), and `str > None`
+                        # raises TypeError, crashing rebuild_index. A single
+                        # such episode is enough to break the whole rebuild.
+                        if (data.get("timestamp") or "") > (topics[phase].get("last_accessed") or ""):
                             topics[phase]["last_accessed"] = data.get("timestamp")
 
         # Index semantic patterns

package/memory/retrieval.py

@@ -414,6 +414,7 @@ class MemoryRetrieval:
         context: Dict[str, Any],
         top_k: int = 5,
         token_budget: Optional[int] = None,
+        persist_boost: bool = False,
     ) -> List[Dict[str, Any]]:
         """
         Retrieve memories with task-type-aware weighting.
@@ -427,6 +428,12 @@ class MemoryRetrieval:
             token_budget: Optional maximum token budget for returned memories.
                          If specified, results will be optimized to fit within
                          this budget using importance/recency/relevance scoring.
+            persist_boost: When True, persist the retrieval-time importance boost
+                         to disk ("use it or lose it" reinforcement). Default
+                         False so manual/on-demand retrievals (dashboard, MCP)
+                         do NOT silently reinforce importance; only the autonomous
+                         RARV loop opts in. The in-memory boost that shapes the
+                         returned ranking is applied either way.
 
         Returns:
             List of memory items with source field indicating origin
@@ -476,10 +483,20 @@ class MemoryRetrieval:
         # Apply recency boost
         merged = self._apply_recency_boost(merged, boost_factor=0.1)
 
-        # Boost importance for retrieved memories (use it or lose it)
+        # Boost importance for retrieved memories (use it or lose it). The
+        # in-memory boost shapes the returned ranking; persist_boost writes the
+        # reinforcement to disk (retrieval-F1: boost_on_retrieval alone never
+        # persisted). Persistence is best-effort: a locked/missing record must
+        # never break retrieval, so failures are swallowed (mirrors other
+        # best-effort writes).
         if hasattr(self.storage, 'boost_on_retrieval'):
             for memory in merged[:top_k]:
                 self.storage.boost_on_retrieval(memory, boost=0.05)
+                if persist_boost and hasattr(self.storage, 'persist_boost'):
+                    try:
+                        self.storage.persist_boost(memory, boost=0.05)
+                    except Exception:
+                        pass
 
         # Apply token budget optimization if specified
         if token_budget is not None and token_budget > 0:

package/memory/storage.py

@@ -1383,6 +1383,142 @@ class MemoryStorage:
 
         return memory
 
+    def persist_boost(
+        self,
+        memory: Dict[str, Any],
+        boost: float = 0.1,
+    ) -> bool:
+        """
+        Persist a retrieval-time boost to disk ("use it or lose it").
+
+        boost_on_retrieval mutates an in-memory dict only; without this the
+        stored importance/access_count never rises, so repeated retrieval can
+        never reinforce a memory against decay (retrieval-F1). This method
+        applies the SAME boost math to the record as it currently exists on
+        disk, under one exclusive _file_lock spanning a FRESH read -> mutate
+        -> _atomic_write (mirrors _decay_episodic / _decay_semantic).
+
+        Race-safety: the boost is applied to the freshly-read record, NOT to
+        the passed-in `memory` dict. So a concurrent content edit landed by
+        another writer is preserved (we only overwrite importance,
+        access_count, last_accessed), and no retrieval-only transient fields
+        (_score, _source, _collection) leak into the stored record. This is
+        the lost-update-safe pattern WAVE6 established for decay.
+
+        Keyed by memory["id"] and the collection marker retrieval attaches
+        (_source, falling back to _collection). Covers episodic (per-file) and
+        semantic patterns.json. Collections without an updater degrade
+        gracefully (return False, no crash):
+          - skills are keyed on disk by name, not id, so an id-keyed boost
+            cannot reliably target the file; skipped honestly.
+          - the legacy semantic/anti-patterns.json store has NO updater
+            anywhere in this module, so there is nothing to write back to;
+            skipped honestly rather than fabricating a writer.
+
+        Args:
+            memory: A retrieved memory dict (must carry "id" and a source
+                marker). The dict itself is not written to disk.
+            boost: Amount to boost importance (default 0.1).
+
+        Returns:
+            True if a record was found and persisted, False otherwise.
+        """
+        memory_id = memory.get("id")
+        if not memory_id:
+            return False
+
+        source = memory.get("_source") or memory.get("_collection") or ""
+
+        if source == "episodic":
+            return self._persist_boost_episodic(str(memory_id), boost)
+        if source == "semantic":
+            return self._persist_boost_semantic(str(memory_id), boost)
+
+        # skills (keyed by name on disk) and the legacy anti-patterns.json
+        # store (no updater exists in this module) cannot be safely targeted
+        # by an id-keyed boost; skip rather than fabricate a writer.
+        return False
+
+    def _persist_boost_episodic(self, memory_id: str, boost: float) -> bool:
+        """Apply and persist a boost to one episodic record, keyed by id.
+
+        Locates the per-file record (task-<id>.json across date dirs) then does
+        a lock-spanning fresh-read -> boost -> atomic-write, mirroring
+        _decay_episodic. The id is sanitized exactly as save_episode does so a
+        sanitized-on-write filename is still found.
+        """
+        episodic_dir = self.base_path / "episodic"
+        if not episodic_dir.exists():
+            return False
+
+        safe_id = "".join(
+            c if c.isalnum() or c in "-_" else "_"
+            for c in memory_id
+        )
+
+        for date_dir in episodic_dir.iterdir():
+            if not date_dir.is_dir():
+                continue
+            file_path = date_dir / f"task-{safe_id}.json"
+            if not file_path.exists():
+                continue
+
+            # One exclusive lock spanning read-mutate-write. boost_on_retrieval
+            # mutates the freshly-read record in place (importance/access_count/
+            # last_accessed only), so a concurrent content edit on disk is
+            # preserved. _atomic_write re-enters the same reentrant lock.
+            with self._file_lock(file_path, exclusive=True):
+                if not file_path.exists():
+                    return False
+                try:
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        data = json.load(f)
+                except (json.JSONDecodeError, OSError, UnicodeDecodeError):
+                    return False
+                if not data:
+                    return False
+                self.boost_on_retrieval(data, boost=boost)
+                self._atomic_write(file_path, data)
+            return True
+
+        return False
+
+    def _persist_boost_semantic(self, memory_id: str, boost: float) -> bool:
+        """Apply and persist a boost to one semantic pattern, keyed by id.
+
+        Patterns live in a single semantic/patterns.json list. Lock-spanning
+        fresh read -> boost the matching entry -> atomic write, mirroring
+        _decay_semantic / save_pattern.
+        """
+        patterns_path = self.base_path / "semantic" / "patterns.json"
+        if not patterns_path.exists():
+            return False
+
+        with self._file_lock(patterns_path, exclusive=True):
+            if not patterns_path.exists():
+                return False
+            try:
+                with open(patterns_path, "r", encoding="utf-8") as f:
+                    patterns_file = json.load(f)
+            except (json.JSONDecodeError, OSError, UnicodeDecodeError):
+                return False
+            if not patterns_file:
+                return False
+
+            patterns = patterns_file.get("patterns", [])
+            for pattern in patterns:
+                if not isinstance(pattern, dict):
+                    continue
+                if pattern.get("id") == memory_id:
+                    self.boost_on_retrieval(pattern, boost=boost)
+                    patterns_file["last_updated"] = datetime.now(
+                        timezone.utc
+                    ).isoformat()
+                    self._atomic_write(patterns_path, patterns_file)
+                    return True
+
+        return False
+
     def batch_apply_decay(
         self,
         collection: str = "all",

package/memory/token_economics.py

@@ -256,6 +256,15 @@ def optimize_context(
             relevance = memory.get("_weighted_score", 0.5)
         else:
             relevance = memory.get("_score", 0.5)
+        # Guard against an explicit null score in a corrupt/hand-edited
+        # record: .get(key, default) returns None when the key is present
+        # but null, and the `relevance > 1.0` comparison below would then
+        # raise "'>' not supported between instances of 'NoneType' and
+        # 'float'". Use an is-None check (not `or`) so a legitimate stored
+        # 0.0 relevance is preserved, mirroring the confidence guard above
+        # and retrieval.py's own base_score guard.
+        if relevance is None:
+            relevance = 0.5
         if relevance > 1.0:
             # Normalize high scores
             relevance = min(1.0, relevance / 10.0)

package/memory/vector_index.py

@@ -42,7 +42,20 @@ class VectorIndex:
         Args:
             dimension: The dimensionality of vectors. Default is 384
                       which matches MiniLM embedding size.
+
+        Raises:
+            ImportError: If numpy is not installed. Every operation in this
+                index (add, search, save, load) relies on numpy, so fail
+                fast with a clear message here rather than letting a later
+                call crash with an opaque ``AttributeError: 'NoneType'
+                object has no attribute ...`` once ``np`` is None. The
+                module-level NUMPY_AVAILABLE flag is what gates this check.
         """
+        if not NUMPY_AVAILABLE:
+            raise ImportError(
+                "numpy is required for the vector index. "
+                "Install it with: pip install numpy"
+            )
         self.dimension = dimension
         self.embeddings: List[np.ndarray] = []
         self.ids: List[str] = []

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.67.0",
+  "version": "7.69.0",
   "description": "Loki Mode by Autonomi. Autonomous spec-to-product system: takes a PRD, GitHub issue, OpenAPI/JSON/YAML, or one-line brief to a deployed app via the RARV-C closure loop with 8 quality gates. Provider-agnostic (Claude Code, OpenAI Codex, Cline, Aider).",
   "keywords": [
     "agent",

package/plugins/loki-mode/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "loki-mode",
   "displayName": "Loki Mode",
-  "version": "7.67.0",
+  "version": "7.69.0",
   "description": "Autonomous spec-to-product build system with a built-in trust layer (RARV-C closure loop, 8 quality gates, completion council). Ships Loki's spec-hardening, drift-detection, and deterministic PR verification commands plus the Loki MCP server.",
   "author": {
     "name": "Autonomi",