loki-mode 7.95.0 → 7.97.0

package/memory/retrieval.py

@@ -269,6 +269,7 @@ class MemoryRetrieval:
         vector_indices: Optional[Dict[str, VectorIndex]] = None,
         base_path: str = ".loki/memory",
         namespace: Optional[str] = None,
+        include_unstamped_legacy: bool = False,
     ):
         """
         Initialize the memory retrieval system.
@@ -279,12 +280,20 @@ class MemoryRetrieval:
             vector_indices: Optional dict of vector indices (episodic, semantic, skills)
             base_path: Base path for memory storage directory
             namespace: Optional namespace for scoped retrieval
+            include_unstamped_legacy: Opt-in escape hatch. When False (the
+                secure default), legacy entries that lack a "_namespace" stamp
+                are EXCLUDED from a namespaced query. This prevents a silent
+                cross-namespace leak where one project reads another project's
+                unstamped memory. Set True only when migrating a single-project
+                store whose entries predate namespace stamping and you have
+                verified every entry belongs to the active namespace.
         """
         self.storage = storage
         self.embedding_engine = embedding_engine
         self.vector_indices = vector_indices or {}
         self.base_path = Path(base_path)
         self._namespace = namespace
+        self._include_unstamped_legacy = include_unstamped_legacy
         # Track when indices were last built to detect staleness (BUG-MEM-002).
         # When consolidation modifies patterns, indices become stale and should
         # be rebuilt before the next similarity search.
@@ -318,25 +327,45 @@ class MemoryRetrieval:
         Behavior:
         - If self._namespace is None, accept all (backward compat for unscoped retrieval).
         - If result has "_namespace" matching, accept.
-        - If result lacks "_namespace" (legacy entry written before stamping),
-          log a deprecation warning (rate-limited) and ACCEPT for backward compat.
-        - Otherwise, reject.
+        - If result lacks "_namespace" (legacy entry written before stamping):
+          treat it conservatively. An unstamped entry has no provable origin,
+          so under a namespaced query it could belong to ANY namespace and
+          including it is a silent cross-namespace leak (one project reading
+          another's memory). By default (self._include_unstamped_legacy is
+          False) such entries are EXCLUDED, with a rate-limited warning telling
+          operators to re-save the entry to add a stamp. Operators who have
+          verified a single-project store predates stamping can opt back in via
+          include_unstamped_legacy=True.
+        - Otherwise (stamp present but does not match), reject.
         """
         if self._namespace is None:
             return True
         result_ns = result.get("_namespace")
         if result_ns is None:
-            # Legacy entry without namespace stamp; accept for backward compat
-            # but warn so operators can re-save to add stamps.
+            # Legacy entry without namespace stamp. No provable origin -> do not
+            # silently leak it across namespaces. Exclude by default; warn so
+            # operators can re-save to add a stamp (rate-limited to avoid spam).
             if MemoryRetrieval._legacy_warned_count < MemoryRetrieval._LEGACY_WARN_LIMIT:
-                logger.warning(
-                    "Memory entry id=%s lacks '_namespace' stamp (legacy "
-                    "entry). Including in results for backward compatibility. "
-                    "Re-save this entry to enable namespace isolation.",
-                    result.get("id", "<unknown>"),
-                )
+                if self._include_unstamped_legacy:
+                    logger.warning(
+                        "Memory entry id=%s lacks '_namespace' stamp (legacy "
+                        "entry). Including under namespace=%s because "
+                        "include_unstamped_legacy is set. Re-save this entry to "
+                        "stamp it and remove the opt-in.",
+                        result.get("id", "<unknown>"),
+                        self._namespace,
+                    )
+                else:
+                    logger.warning(
+                        "Memory entry id=%s lacks '_namespace' stamp (legacy "
+                        "entry). Excluding from namespace=%s query to prevent a "
+                        "cross-namespace leak. Re-save this entry to stamp it, "
+                        "or pass include_unstamped_legacy=True to opt in.",
+                        result.get("id", "<unknown>"),
+                        self._namespace,
+                    )
                 MemoryRetrieval._legacy_warned_count += 1
-            return True
+            return self._include_unstamped_legacy
         return result_ns == self._namespace
 
     def with_namespace(self, namespace: str) -> "MemoryRetrieval":
@@ -361,6 +390,7 @@ class MemoryRetrieval:
             vector_indices=self.vector_indices,
             base_path=str(self.base_path),
             namespace=namespace,
+            include_unstamped_legacy=self._include_unstamped_legacy,
         )
 
     # -------------------------------------------------------------------------

package/memory/storage.py

@@ -33,6 +33,29 @@ except ImportError:
 # Default namespace constant
 DEFAULT_NAMESPACE = "default"
 
+# Allowed namespace characters. A namespace becomes a single path segment under
+# the memory root, so it must not contain separators, traversal, or whitespace.
+_NAMESPACE_RE = re.compile(r'^[a-zA-Z0-9_-]+$')
+
+
+def _validate_namespace_charset(namespace: str) -> None:
+    """Reject a namespace whose characters could escape its directory.
+
+    Charset-only check, shared by ``__init__`` and ``with_namespace`` so the two
+    validation sites cannot drift. Callers are responsible for deciding whether a
+    None/empty namespace is acceptable (it is in ``__init__`` for backward
+    compat; it is rejected in ``with_namespace``); this only runs once a concrete
+    non-default namespace string is present.
+
+    Raises:
+        ValueError: If the namespace contains anything outside [A-Za-z0-9_-].
+    """
+    if not _NAMESPACE_RE.match(namespace):
+        raise ValueError(
+            f"Invalid namespace '{namespace}': "
+            "only alphanumeric characters, hyphens, and underscores are allowed"
+        )
+
 
 class MemoryStorage:
     """
@@ -73,14 +96,11 @@ class MemoryStorage:
         self._root_path = Path(effective_base)
         self._namespace = namespace
 
-        # Validate namespace to prevent path traversal
+        # Validate namespace to prevent path traversal. None/empty is accepted
+        # here for backward compat (it selects the default, un-namespaced root);
+        # only a concrete non-default namespace is charset-checked.
         if namespace and namespace != DEFAULT_NAMESPACE:
-            import re
-            if not re.match(r'^[a-zA-Z0-9_-]+$', namespace):
-                raise ValueError(
-                    f"Invalid namespace '{namespace}': "
-                    "only alphanumeric characters, hyphens, and underscores are allowed"
-                )
+            _validate_namespace_charset(namespace)
 
         # Calculate effective base path (with namespace if specified)
         if namespace and namespace != DEFAULT_NAMESPACE:
@@ -119,15 +139,21 @@ class MemoryStorage:
             New MemoryStorage instance for the specified namespace
 
         Raises:
-            ValueError: If namespace contains path traversal characters
-        """
-        import re
-        if namespace and namespace != DEFAULT_NAMESPACE:
-            if not re.match(r'^[a-zA-Z0-9_-]+$', namespace):
-                raise ValueError(
-                    f"Invalid namespace '{namespace}': "
-                    "only alphanumeric characters, hyphens, and underscores are allowed"
-                )
+            ValueError: If namespace is empty/None/non-string, or contains
+                characters outside [A-Za-z0-9_-] (path-traversal defense).
+        """
+        # with_namespace is an explicit "switch to this namespace" call, so an
+        # empty, None, whitespace-only, or non-string namespace is meaningless
+        # and must be rejected rather than silently resolving to the default
+        # root (which is what __init__ would do with a falsy namespace). Reject,
+        # do not normalize: normalization would mask a caller bug.
+        if not isinstance(namespace, str) or not namespace.strip():
+            raise ValueError(
+                f"Invalid namespace {namespace!r}: "
+                "must be a non-empty string"
+            )
+        if namespace != DEFAULT_NAMESPACE:
+            _validate_namespace_charset(namespace)
         return MemoryStorage(
             base_path=str(self._root_path),
             namespace=namespace,
@@ -857,6 +883,75 @@ class MemoryStorage:
 
         return True
 
+    def update_pattern_with_merge(self, pattern_id: str, merge_fn) -> bool:
+        """Atomically merge into an existing pattern under a single lock.
+
+        Closes the consolidation lost-update (BUG-MEM C1): the previous flow read
+        the pattern (load_pattern) and wrote the merged result (update_pattern) in
+        SEPARATE lock acquisitions, so a concurrent increment_pattern_usage() bump
+        landing between the read and the write was lost. Here the read of the
+        current on-disk record, the caller's merge, and the write all happen
+        inside ONE exclusive _file_lock on patterns.json -- the same path
+        increment_pattern_usage() and update_pattern() lock -- so they mutually
+        exclude and no bump is clobbered.
+
+        Args:
+            pattern_id: Id of the existing pattern to merge into.
+            merge_fn: Callable taking the current on-disk pattern dict and
+                returning the merged record (dict, or any object exposing
+                to_dict()/__dict__). It must preserve the id. The dict it
+                receives is a fresh read performed under the lock.
+
+        Returns:
+            True if the pattern was found and the merged record written, False if
+            the pattern id was not present (caller should fall back to a create).
+        """
+        if not pattern_id:
+            return False
+
+        patterns_path = self.base_path / "semantic" / "patterns.json"
+
+        with self._file_lock(patterns_path, exclusive=True):
+            if not patterns_path.exists():
+                return False
+
+            with open(patterns_path, "r", encoding="utf-8") as f:
+                try:
+                    patterns_file = json.load(f)
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    return False
+
+            patterns = patterns_file.get("patterns", [])
+            target_idx = None
+            current = None
+            for i, p in enumerate(patterns):
+                if isinstance(p, dict) and p.get("id") == pattern_id:
+                    target_idx = i
+                    current = p
+                    break
+
+            if target_idx is None:
+                return False
+
+            # Caller merges against the fresh, lock-protected current record.
+            merged = merge_fn(current)
+            if hasattr(merged, "to_dict"):
+                merged_data = merged.to_dict()
+            elif hasattr(merged, "__dict__"):
+                merged_data = merged.__dict__.copy()
+            else:
+                merged_data = dict(merged)
+
+            # Never let a merge orphan the record by changing its id.
+            merged_data["id"] = pattern_id
+            merged_data["updated_at"] = datetime.now(timezone.utc).isoformat()
+            patterns_file["patterns"][target_idx] = merged_data
+            patterns_file["last_updated"] = datetime.now(timezone.utc).isoformat()
+
+            self._atomic_write(patterns_path, patterns_file)
+
+        return True
+
     # -------------------------------------------------------------------------
     # Skill Storage
     # -------------------------------------------------------------------------
@@ -1259,9 +1354,20 @@ class MemoryStorage:
                 base = min(1.0, base + 0.05 * min(len(errors), 3))
 
         # Access frequency boost (diminishing returns).
-        # `or 0` guards against an explicit null access_count crashing the
-        # comparison and log1p call below.
+        # `or 0` guards an explicit null access_count; the isinstance/`< 0`
+        # clamp additionally guards a non-numeric (e.g. a stored "5") or negative
+        # value (corrupt or hand-edited record) reaching the `> 0` comparison and
+        # log1p() below. A bare string raises TypeError on `"5" > 0`, and a
+        # negative <= -1 raises a math domain error in log1p; bool is excluded so
+        # a stray True is not treated as a count of 1. All coerce to 0 (no boost)
+        # so importance scoring never crashes the scan.
         access_count = memory.get("access_count") or 0
+        if (
+            not isinstance(access_count, (int, float))
+            or isinstance(access_count, bool)
+            or access_count < 0
+        ):
+            access_count = 0
         if access_count > 0:
             # Log scale boost, caps at about 0.15 for 100+ accesses
             access_boost = 0.05 * math.log1p(access_count)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "loki-mode",
   "mcpName": "io.github.asklokesh/loki-mode",
-  "version": "7.95.0",
+  "version": "7.97.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.95.0",
+  "version": "7.97.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",