loki-mode 7.81.1 → 7.83.0

package/memory/retrieval.py

@@ -829,6 +829,32 @@ class MemoryRetrieval:
 
         return items
 
+    @staticmethod
+    def _parse_episode_timestamp(value: Any) -> Optional[datetime]:
+        """Parse an episode timestamp to a tz-aware datetime, or None.
+
+        Accepts ISO-8601 strings (with or without a trailing Z) and existing
+        datetime objects. Returns None when the value is missing or cannot be
+        parsed, so callers can fall back to coarser filtering instead of
+        crashing on a corrupt record. Naive results are assumed UTC so they
+        compare correctly against tz-aware bounds.
+        """
+        if not value:
+            return None
+        try:
+            if isinstance(value, datetime):
+                dt = value
+            elif isinstance(value, str):
+                s = value[:-1] + "+00:00" if value.endswith("Z") else value
+                dt = datetime.fromisoformat(s)
+            else:
+                return None
+        except (ValueError, TypeError):
+            return None
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt
+
     def retrieve_by_temporal(
         self,
         since: datetime,
@@ -848,6 +874,12 @@ class MemoryRetrieval:
             List of memories within the time range
         """
         until = until or datetime.now(timezone.utc)
+        # Normalize bounds to tz-aware UTC so comparisons against tz-aware
+        # episode/pattern timestamps below never raise on a naive bound.
+        if since.tzinfo is None:
+            since = since.replace(tzinfo=timezone.utc)
+        if until.tzinfo is None:
+            until = until.replace(tzinfo=timezone.utc)
         results: List[Dict[str, Any]] = []
 
         # Search episodic memories by date directory (via storage layer)
@@ -873,6 +905,17 @@ class MemoryRetrieval:
                         f"episodic/{date_dir.name}/{episode_file.name}"
                     )
                     if data:
+                        # The date-dir match above is a coarse, day-granularity
+                        # prefilter. Without this per-episode timestamp check, an
+                        # episode at 08:00 on the `since` day was returned even
+                        # when `since` was 14:00 that same day (and likewise at
+                        # the `until` boundary). Filter each episode by its own
+                        # timestamp when one is present and parseable; episodes
+                        # with a missing/unparseable timestamp keep the previous
+                        # day-level behavior rather than being silently dropped.
+                        ep_ts = self._parse_episode_timestamp(data.get("timestamp"))
+                        if ep_ts is not None and not (since <= ep_ts <= until):
+                            continue
                         data["_source"] = "episodic"
                         if self._belongs_to_namespace(data):
                             results.append(data)
@@ -1038,7 +1081,23 @@ class MemoryRetrieval:
         # Sort by weighted score
         all_results.sort(key=lambda x: x.get("_weighted_score", 0), reverse=True)
 
-        return all_results[:top_k]
+        # Defense-in-depth dedup by id. The same record can legitimately reach
+        # more than one collection bucket (e.g. an anti-pattern bridged into the
+        # anti_patterns source while a category filter is also expected upstream).
+        # Keep the highest-scoring copy: results are already sorted descending, so
+        # the first occurrence of an id is the best one. Records without an id are
+        # never collapsed together (each keeps its own slot).
+        deduped: List[Dict[str, Any]] = []
+        seen_ids: set = set()
+        for item in all_results:
+            item_id = item.get("id")
+            if item_id is not None:
+                if item_id in seen_ids:
+                    continue
+                seen_ids.add(item_id)
+            deduped.append(item)
+
+        return deduped[:top_k]
 
     def _apply_recency_boost(
         self,
@@ -1076,11 +1135,19 @@ class MemoryRetrieval:
                 if item_time.tzinfo is None:
                     item_time = item_time.replace(tzinfo=timezone.utc)
 
-                # Calculate age in days
-                age_days = (now - item_time).days
-
-                # Boost decays linearly over 30 days
-                if age_days < 30:
+                # Calculate age in days. Use total_seconds()/86400 for a
+                # continuous value (the .days attribute truncates to whole days,
+                # losing sub-day resolution, e.g. an 18-hour-old record reads as
+                # age 0 instead of 0.75).
+                age_days = (now - item_time).total_seconds() / 86400.0
+
+                # Boost decays linearly over 30 days. Gate on [0, 30): a
+                # future-dated record (clock skew or a forward-stamped entry)
+                # has a negative age and must NOT be treated as the freshest
+                # record. The old code (age_days < 30) let a negative age through
+                # and produced boost = boost_factor * (1 - negative/30) > the
+                # intended cap, inflating future records above all real ones.
+                if 0 <= age_days < 30:
                     boost = boost_factor * (1 - age_days / 30)
                     current_score = result.get("_weighted_score", result.get("_score", 0.5))
                     result["_weighted_score"] = current_score * (1 + boost)
@@ -1483,153 +1550,6 @@ class MemoryRetrieval:
     # Private Helper Methods
     # -------------------------------------------------------------------------
 
-    # -------------------------------------------------------------------------
-    # Optional structure-aware tree retrieval (PageIndex pattern, OFF by default)
-    # -------------------------------------------------------------------------
-
-    def retrieve_tree(
-        self,
-        context: Dict[str, Any],
-        top_k: int = 5,
-        manifest: Optional[Dict[str, Any]] = None,
-        store: Optional[Any] = None,
-        llm: Optional[Callable[[str], str]] = None,
-    ) -> List[Dict[str, Any]]:
-        """Structure-aware tree retrieval over the code-index manifest.
-
-        Third, parallel, OPTIONAL retrieval path alongside keyword and vector.
-        It is NEVER reached unless a caller invokes it (directly or through the
-        LOKI_RETRIEVAL_MODE=tree dispatcher in retrieve_dispatch). The default
-        retrieve_task_aware path is byte-unchanged.
-
-        Builds (or loads from the LokiStore cache) a TOC tree from the code
-        index manifest, then reasons down it for the query. Degrades to a
-        deterministic keyword scorer when no LLM callable is available, and
-        further degrades to the existing keyword retrieval path when the
-        manifest itself is absent.
-
-        Args:
-            context: query context (goal, phase, action_type, files).
-            top_k: maximum number of results.
-            manifest: parsed code-index manifest. When None, it is loaded from
-                .loki/state/code-index-manifest.json (relative to the store).
-            store: a LokiStore for caching the built tree. When None, one is
-                built via lokistore.get_store() (local default, no new deps).
-            llm: optional LLM callable (prompt -> response) for reasoning
-                descent. When None, the keyword scorer is used.
-
-        Returns:
-            A ranked list of result dicts. Each carries "_source": "tree".
-            On any failure or a missing manifest, falls back to the existing
-            keyword retrieval so the caller always gets results.
-        """
-        # Local imports keep these optional modules off the default import path.
-        try:
-            from .tree_index import build_or_load_manifest_tree
-            from .tree_search import tree_search
-        except ImportError as exc:  # pragma: no cover - defensive
-            logger.warning("tree retrieval modules unavailable: %s", exc)
-            return self._tree_keyword_fallback(context, top_k)
-
-        if store is None:
-            try:
-                from lokistore import get_store
-
-                store = get_store()
-            except Exception as exc:  # noqa: BLE001 - degrade, never abort
-                logger.warning("could not obtain LokiStore for tree cache: %s", exc)
-                store = None
-
-        if manifest is None:
-            manifest = self._load_code_index_manifest(store)
-
-        if not manifest or not (manifest.get("files") or {}):
-            # No structure to reason over: fall back to keyword retrieval so
-            # the caller still gets results.
-            return self._tree_keyword_fallback(context, top_k)
-
-        query = self._build_query_from_context(context)
-
-        try:
-            if store is not None:
-                tree = build_or_load_manifest_tree(manifest, store)
-            else:
-                from .tree_index import build_tree_from_manifest
-
-                tree = build_tree_from_manifest(manifest)
-            return tree_search(tree, query, top_k=top_k, llm=llm)
-        except Exception as exc:  # noqa: BLE001 - degrade, never abort
-            logger.warning("tree retrieval failed (%s); using keyword fallback", exc)
-            return self._tree_keyword_fallback(context, top_k)
-
-    def retrieve_dispatch(
-        self,
-        context: Dict[str, Any],
-        top_k: int = 5,
-        token_budget: Optional[int] = None,
-        mode: Optional[str] = None,
-        **tree_kwargs: Any,
-    ) -> List[Dict[str, Any]]:
-        """Dispatch to a retrieval mode, defaulting to the existing path.
-
-        Mode resolution (first non-empty wins):
-          1. explicit `mode` argument
-          2. LOKI_RETRIEVAL_MODE env var
-          3. "task_aware" (the existing default path)
-
-        Only mode == "tree" diverges; every other value (including the default)
-        calls retrieve_task_aware UNCHANGED, so local devs who set nothing get
-        byte-identical behavior. Unknown modes also fall through to the default.
-        """
-        import os as _os
-
-        resolved = (mode or _os.environ.get("LOKI_RETRIEVAL_MODE") or "task_aware")
-        resolved = resolved.strip().lower()
-
-        if resolved == "tree":
-            return self.retrieve_tree(context, top_k=top_k, **tree_kwargs)
-
-        # Default and any unknown mode: existing behavior, untouched.
-        return self.retrieve_task_aware(
-            context, top_k=top_k, token_budget=token_budget
-        )
-
-    def _load_code_index_manifest(
-        self, store: Optional[Any]
-    ) -> Optional[Dict[str, Any]]:
-        """Load the code-index manifest, preferring the LokiStore.
-
-        Tries the store key "state/code-index-manifest.json" first (so it
-        honors LOKI_DIR / TARGET_DIR resolution), then a direct filesystem
-        read as a fallback. Returns None when no manifest is found.
-        """
-        manifest_key = "state/code-index-manifest.json"
-        if store is not None:
-            try:
-                if store.exists(manifest_key):
-                    raw = store.get(manifest_key)
-                    return json.loads(raw.decode("utf-8"))
-            except (FileNotFoundError, OSError, ValueError, UnicodeDecodeError):
-                pass
-        # Filesystem fallback relative to the configured base path.
-        candidate = Path(".loki/state/code-index-manifest.json")
-        try:
-            if candidate.is_file():
-                return json.loads(candidate.read_text(encoding="utf-8"))
-        except (OSError, ValueError):
-            pass
-        return None
-
-    def _tree_keyword_fallback(
-        self, context: Dict[str, Any], top_k: int
-    ) -> List[Dict[str, Any]]:
-        """Fallback used by tree retrieval: the existing keyword path.
-
-        Reuses retrieve_task_aware so a tree-mode caller is never worse off
-        than the default mode when the manifest or an LLM is unavailable.
-        """
-        return self.retrieve_task_aware(context, top_k=top_k)
-
     def _build_query_from_context(self, context: Dict[str, Any]) -> str:
         """Build a query string from context dictionary."""
         parts = []
@@ -1723,6 +1643,14 @@ class MemoryRetrieval:
         for pattern in patterns_data.get("patterns", []):
             if not isinstance(pattern, dict):
                 continue
+            # Anti-patterns live in this same patterns.json (consolidation
+            # writes them as SemanticPattern records with category="anti-pattern").
+            # They are surfaced separately by _keyword_search_anti_patterns, which
+            # bridges those records into the anti_patterns source. Including them
+            # here too returns the same record twice (once as semantic, once as
+            # anti_patterns), double-counting and wasting token budget. Skip them.
+            if (pattern.get("category") or "").lower() == "anti-pattern":
+                continue
             # Defensive: corrupt or hand-edited records may carry null
             # string fields; (x or "") avoids AttributeError on None.
             pattern_text = (pattern.get("pattern") or "").lower()

package/package.json

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

package/providers/codex.sh

@@ -73,10 +73,15 @@ _codex_validate_model() {
     echo "$CODEX_DEFAULT_MODEL"
 }
 
-# Provider-specific env (LOKI_CODEX_MODEL) is trusted; generic LOKI_MODEL_* is validated
-PROVIDER_MODEL_PLANNING="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_PLANNING:-$CODEX_DEFAULT_MODEL}}")"
-PROVIDER_MODEL_DEVELOPMENT="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_DEVELOPMENT:-$CODEX_DEFAULT_MODEL}}")"
-PROVIDER_MODEL_FAST="$(_codex_validate_model "${LOKI_CODEX_MODEL:-${LOKI_MODEL_FAST:-$CODEX_DEFAULT_MODEL}}")"
+# Provider-specific env (LOKI_CODEX_MODEL) is trusted and used verbatim -- the
+# operator set a Codex-specific model on purpose (e.g. a fine-tune or org-scoped
+# name that need not match CODEX_KNOWN_MODELS). Only the GENERIC LOKI_MODEL_*
+# fallback is validated, since it may carry Claude aliases (opus/sonnet/haiku)
+# that are invalid for Codex. Validating the whole chain silently downgraded a
+# trusted LOKI_CODEX_MODEL to the default (BUG-PROV-003 fix).
+PROVIDER_MODEL_PLANNING="${LOKI_CODEX_MODEL:-$(_codex_validate_model "${LOKI_MODEL_PLANNING:-$CODEX_DEFAULT_MODEL}")}"
+PROVIDER_MODEL_DEVELOPMENT="${LOKI_CODEX_MODEL:-$(_codex_validate_model "${LOKI_MODEL_DEVELOPMENT:-$CODEX_DEFAULT_MODEL}")}"
+PROVIDER_MODEL_FAST="${LOKI_CODEX_MODEL:-$(_codex_validate_model "${LOKI_MODEL_FAST:-$CODEX_DEFAULT_MODEL}")}"
 
 # Effort levels (Codex-specific: maps to reasoning time, not model capability)
 PROVIDER_EFFORT_PLANNING="xhigh"