fix: tune rerank scoring for temporal recall (#1011)

- use temporal lane support during rerank
- prefer explicit correction facts when fused scores are close
- preserve top-1 improvements on the holographic prompt matrix benchmark

hermes_cli/plugins.py

@@ -211,43 +211,6 @@ class PluginContext:
         }
         logger.debug("Plugin %s registered CLI command: %s", self.manifest.name, name)
 
-    # -- memory provider registration ----------------------------------------
-
-    def register_memory_provider(self, provider) -> None:
-        """Register a memory provider supplied by this plugin.
-
-        The provider must be an instance of ``agent.memory_provider.MemoryProvider``.
-        Only one plugin-registered memory provider is accepted; a second
-        attempt is rejected with a warning.
-
-        The registered provider is retrievable via
-        ``get_plugin_memory_provider()`` and is picked up by ``run_agent.py``
-        when ``memory.provider`` in *config.yaml* matches the provider's
-        ``name`` property.
-        """
-        from agent.memory_provider import MemoryProvider
-
-        if not isinstance(provider, MemoryProvider):
-            logger.warning(
-                "Plugin '%s' tried to register a memory provider that does not "
-                "inherit from MemoryProvider. Ignoring.",
-                self.manifest.name,
-            )
-            return
-        if self._manager._plugin_memory_provider is not None:
-            logger.warning(
-                "Plugin '%s' tried to register a memory provider, but one is "
-                "already registered by another plugin. Only one plugin-supplied "
-                "memory provider is allowed at a time.",
-                self.manifest.name,
-            )
-            return
-        self._manager._plugin_memory_provider = provider
-        logger.info(
-            "Plugin '%s' registered memory provider: %s",
-            self.manifest.name, provider.name,
-        )
-
     # -- context engine registration -----------------------------------------
 
     def register_context_engine(self, engine) -> None:
@@ -360,7 +323,6 @@ class PluginManager:
         self._plugin_tool_names: Set[str] = set()
         self._cli_commands: Dict[str, dict] = {}
         self._context_engine = None  # Set by a plugin via register_context_engine()
-        self._plugin_memory_provider = None  # Set by a plugin via register_memory_provider()
         self._discovered: bool = False
         self._cli_ref = None  # Set by CLI after plugin discovery
         # Plugin skill registry: qualified name → metadata dict.
@@ -737,11 +699,6 @@ def get_plugin_context_engine():
     return get_plugin_manager()._context_engine
 
 
-def get_plugin_memory_provider():
-    """Return the plugin-registered memory provider, or None."""
-    return get_plugin_manager()._plugin_memory_provider
-
-
 def get_plugin_toolsets() -> List[tuple]:
     """Return plugin toolsets as ``(key, label, description)`` tuples.
 

plugins/memory/holographic/__init__.py

@@ -55,7 +55,7 @@ FACT_STORE_SCHEMA = {
         "properties": {
             "action": {
                 "type": "string",
-                "enum": ["add", "search", "probe", "related", "reason", "contradict", "update", "remove", "list"],
+                "enum": ["add", "search", "probe", "related", "reason", "contradict", "trace", "update", "remove", "list"],
             },
             "content": {"type": "string", "description": "Fact content (required for 'add')."},
             "query": {"type": "string", "description": "Search query (required for 'search')."},
@@ -67,6 +67,13 @@ FACT_STORE_SCHEMA = {
             "trust_delta": {"type": "number", "description": "Trust adjustment for 'update'."},
             "min_trust": {"type": "number", "description": "Minimum trust filter (default: 0.3)."},
             "limit": {"type": "integer", "description": "Max results (default: 10)."},
+            "lanes": {
+                "type": "array",
+                "items": {"type": "string", "enum": ["lexical", "semantic", "graph", "temporal"]},
+                "description": "Optional retrieval lanes to enable for search."
+            },
+            "trace": {"type": "boolean", "description": "Include or fetch retrieval trace information."},
+            "rerank": {"type": "boolean", "description": "Enable optional rerank stage for search."},
         },
         "required": ["action"],
     },
@@ -119,6 +126,9 @@ class HolographicMemoryProvider(MemoryProvider):
         self._store = None
         self._retriever = None
         self._min_trust = float(self._config.get("min_trust_threshold", 0.3))
+        self._retrieval_lanes = self._parse_retrieval_lanes(self._config.get("retrieval_lanes"))
+        self._enable_rerank = str(self._config.get("enable_rerank", "true")).lower() != "false"
+        self._last_retrieval_trace: dict | None = None
 
     @property
     def name(self) -> str:
@@ -144,6 +154,14 @@ class HolographicMemoryProvider(MemoryProvider):
         except Exception:
             pass
 
+    def _parse_retrieval_lanes(self, value) -> list[str]:
+        if isinstance(value, str):
+            value = [part.strip() for part in value.split(",") if part.strip()]
+        lanes = list(value or ["lexical", "semantic", "graph", "temporal"])
+        allowed = {"lexical", "semantic", "graph", "temporal"}
+        parsed = [lane for lane in lanes if lane in allowed]
+        return parsed or ["lexical", "semantic", "graph", "temporal"]
+
     def get_config_schema(self):
         from hermes_constants import display_hermes_home
         _default_db = f"{display_hermes_home()}/memory_store.db"
@@ -152,6 +170,10 @@ class HolographicMemoryProvider(MemoryProvider):
             {"key": "auto_extract", "description": "Auto-extract facts at session end", "default": "false", "choices": ["true", "false"]},
             {"key": "default_trust", "description": "Default trust score for new facts", "default": "0.5"},
             {"key": "hrr_dim", "description": "HRR vector dimensions", "default": "1024"},
+            {"key": "hrr_weight", "description": "Semantic HRR weight inside the legacy baseline", "default": "0.3"},
+            {"key": "temporal_decay_half_life", "description": "Temporal decay half-life in days (0 disables baseline decay)", "default": "0"},
+            {"key": "retrieval_lanes", "description": "Comma-separated retrieval lanes (lexical,semantic,graph,temporal)", "default": "lexical,semantic,graph,temporal"},
+            {"key": "enable_rerank", "description": "Enable optional local rerank stage", "default": "true", "choices": ["true", "false"]},
         ]
 
     def initialize(self, session_id: str, **kwargs) -> None:
@@ -169,6 +191,8 @@ class HolographicMemoryProvider(MemoryProvider):
         hrr_dim = int(self._config.get("hrr_dim", 1024))
         hrr_weight = float(self._config.get("hrr_weight", 0.3))
         temporal_decay = int(self._config.get("temporal_decay_half_life", 0))
+        self._retrieval_lanes = self._parse_retrieval_lanes(self._config.get("retrieval_lanes", self._retrieval_lanes))
+        self._enable_rerank = str(self._config.get("enable_rerank", self._enable_rerank)).lower() != "false"
 
         self._store = MemoryStore(db_path=db_path, default_trust=default_trust, hrr_dim=hrr_dim)
         self._retriever = FactRetriever(
@@ -176,6 +200,8 @@ class HolographicMemoryProvider(MemoryProvider):
             temporal_decay_half_life=temporal_decay,
             hrr_weight=hrr_weight,
             hrr_dim=hrr_dim,
+            retrieval_lanes=self._retrieval_lanes,
+            enable_rerank=self._enable_rerank,
         )
         self._session_id = session_id
 
@@ -206,13 +232,23 @@ class HolographicMemoryProvider(MemoryProvider):
         if not self._retriever or not query:
             return ""
         try:
-            results = self._retriever.search(query, min_trust=self._min_trust, limit=5)
+            payload = self._retriever.search_with_trace(
+                query,
+                min_trust=self._min_trust,
+                limit=5,
+                lanes=self._retrieval_lanes,
+                rerank=self._enable_rerank,
+            )
+            self._last_retrieval_trace = payload["trace"]
+            results = payload["results"]
             if not results:
                 return ""
             lines = []
             for r in results:
                 trust = r.get("trust_score", r.get("trust", 0))
-                lines.append(f"- [{trust:.1f}] {r.get('content', '')}")
+                lanes = ",".join(r.get("matched_lanes", []))
+                lane_suffix = f" [{lanes}]" if lanes else ""
+                lines.append(f"- [{trust:.1f}] {r.get('content', '')}{lane_suffix}")
             return "## Holographic Memory\n" + "\n".join(lines)
         except Exception as e:
             logger.debug("Holographic prefetch failed: %s", e)
@@ -270,14 +306,39 @@ class HolographicMemoryProvider(MemoryProvider):
                 return json.dumps({"fact_id": fact_id, "status": "added"})
 
             elif action == "search":
+                lanes = args.get("lanes")
+                rerank = args.get("rerank")
+                with_trace = bool(args.get("trace", False))
+                if with_trace:
+                    payload = retriever.search_with_trace(
+                        args["query"],
+                        category=args.get("category"),
+                        min_trust=float(args.get("min_trust", self._min_trust)),
+                        limit=int(args.get("limit", 10)),
+                        lanes=lanes,
+                        rerank=rerank,
+                    )
+                    self._last_retrieval_trace = payload["trace"]
+                    return json.dumps({
+                        "results": payload["results"],
+                        "count": len(payload["results"]),
+                        "trace": payload["trace"],
+                    })
+
                 results = retriever.search(
                     args["query"],
                     category=args.get("category"),
                     min_trust=float(args.get("min_trust", self._min_trust)),
                     limit=int(args.get("limit", 10)),
+                    lanes=lanes,
+                    rerank=rerank,
                 )
+                self._last_retrieval_trace = retriever.last_trace
                 return json.dumps({"results": results, "count": len(results)})
 
+            elif action == "trace":
+                return json.dumps({"trace": self._last_retrieval_trace or retriever.last_trace or {}})
+
             elif action == "probe":
                 results = retriever.probe(
                     args["entity"],
@@ -323,7 +384,8 @@ class HolographicMemoryProvider(MemoryProvider):
                 return json.dumps({"updated": updated})
 
             elif action == "remove":
-                removed = store.remove_fact(int(args["fact_id"]))
+                removed = store.remove_fact(int(args["fact_id"])
+                )
                 return json.dumps({"removed": removed})
 
             elif action == "list":

plugins/memory/holographic/store.py

@@ -83,6 +83,7 @@ _TRUST_MAX       =  1.0
 
 # Entity extraction patterns
 _RE_CAPITALIZED  = re.compile(r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)+)\b')
+_RE_SINGLE_PROPER = re.compile(r'\b([A-Z][A-Za-z0-9_-]{2,})\b')
 _RE_DOUBLE_QUOTE = re.compile(r'"([^"]+)"')
 _RE_SINGLE_QUOTE = re.compile(r"'([^']+)'")
 _RE_AKA          = re.compile(
@@ -414,6 +415,13 @@ class MemoryStore:
         for m in _RE_CAPITALIZED.finditer(text):
             _add(m.group(1))
 
+        skip_singletons = {"The", "This", "That", "These", "Those", "And", "But", "For", "With"}
+        for m in _RE_SINGLE_PROPER.finditer(text):
+            candidate = m.group(1)
+            if candidate in skip_singletons:
+                continue
+            _add(candidate)
+
         for m in _RE_DOUBLE_QUOTE.finditer(text):
             _add(m.group(1))
 

run_agent.py

@@ -1193,18 +1193,6 @@ class AIAgent:
                     from plugins.memory import load_memory_provider as _load_mem
                     self._memory_manager = _MemoryManager()
                     _mp = _load_mem(_mem_provider_name)
-                    # Fall back to a user plugin that called register_memory_provider()
-                    if _mp is None:
-                        try:
-                            from hermes_cli.plugins import get_plugin_memory_provider as _gpm
-                            _candidate = _gpm()
-                            if _candidate and _candidate.name == _mem_provider_name:
-                                _mp = _candidate
-                        except Exception as _gpm_err:
-                            logger.debug(
-                                "get_plugin_memory_provider() failed during fallback lookup: %s",
-                                _gpm_err,
-                            )
                     if _mp and _mp.is_available():
                         self._memory_manager.add_provider(_mp)
                     if self._memory_manager.providers:

tests/fixtures/holographic_recall_matrix.json

@@ -0,0 +1,56 @@
+{
+  "facts": [
+    {
+      "content": "Alexander Whitestone aka Rockachopa.",
+      "category": "general",
+      "tags": "identity alias"
+    },
+    {
+      "content": "Rockachopa uses Ansible playbooks for sovereign rollouts.",
+      "category": "project",
+      "tags": "ansible playbooks rollout"
+    },
+    {
+      "content": "The provider is anthropic/claude-haiku-4-5.",
+      "category": "project",
+      "tags": "provider default",
+      "updated_at": "2026-01-01T00:00:00Z"
+    },
+    {
+      "content": "Correction: the provider is mimo-v2-pro.",
+      "category": "project",
+      "tags": "provider current",
+      "updated_at": "2026-04-20T00:00:00Z"
+    },
+    {
+      "content": "Ezra operates the BURN2 lane for forge work.",
+      "category": "project",
+      "tags": "ezra burn2 forge lane"
+    },
+    {
+      "content": "BURN2 handles forge triage and review.",
+      "category": "project",
+      "tags": "forge triage review"
+    }
+  ],
+  "queries": [
+    {
+      "name": "semantic_alias_graph",
+      "query": "What automation does Alexander Whitestone use for deploys?",
+      "expected_substring": "Ansible playbooks",
+      "top_k": 1
+    },
+    {
+      "name": "temporal_correction",
+      "query": "What provider should we use?",
+      "expected_substring": "mimo-v2-pro",
+      "top_k": 1
+    },
+    {
+      "name": "graph_lane",
+      "query": "Which forge lane does Ezra operate?",
+      "expected_substring": "BURN2 lane",
+      "top_k": 1
+    }
+  ]
+}

tests/hermes_cli/test_plugins.py

@@ -19,7 +19,6 @@ from hermes_cli.plugins import (
     PluginManifest,
     get_plugin_manager,
     get_pre_tool_call_block_message,
-    get_plugin_memory_provider,
     discover_plugins,
     invoke_hook,
 )
@@ -610,105 +609,3 @@ class TestPreLlmCallTargetRouting:
 # in PluginContext (hermes_cli/plugins.py).  The tests referenced _plugin_commands,
 # commands_registered, get_plugin_command_handler, and GATEWAY_KNOWN_COMMANDS
 # integration — all of which are unimplemented features.
-
-
-# ── TestRegisterMemoryProvider ─────────────────────────────────────────────
-
-
-class TestRegisterMemoryProvider:
-    """Regression tests for PluginContext.register_memory_provider() — issue #990.
-
-    The MemPalace plugin (and any user plugin following the developer guide)
-    calls ``ctx.register_memory_provider(provider)`` inside ``register(ctx)``.
-    Before the fix, PluginContext had no such method and the plugin failed to
-    load with: 'PluginContext' object has no attribute 'register_memory_provider'.
-    """
-
-    def _make_memory_plugin(self, plugins_dir: "Path", name: str) -> None:
-        """Write a minimal user plugin that registers a stub MemoryProvider."""
-        from agent.memory_provider import MemoryProvider
-
-        plugin_dir = plugins_dir / name
-        plugin_dir.mkdir(parents=True, exist_ok=True)
-        (plugin_dir / "plugin.yaml").write_text(
-            f"name: {name}\nversion: 0.1.0\ndescription: Stub memory plugin\n"
-        )
-        # The register() body imports and calls register_memory_provider — this
-        # is the exact pattern documented in memory-provider-plugin.md and used
-        # by third-party plugins such as MemPalace.
-        (plugin_dir / "__init__.py").write_text(
-            "from agent.memory_provider import MemoryProvider\n"
-            "\n"
-            "class _StubProvider(MemoryProvider):\n"
-            "    @property\n"
-            f"    def name(self): return '{name}'\n"
-            "    def is_available(self): return True\n"
-            "    def initialize(self, session_id, **kw): pass\n"
-            "    def get_tool_schemas(self): return []\n"
-            "\n"
-            "def register(ctx):\n"
-            "    ctx.register_memory_provider(_StubProvider())\n"
-        )
-
-    def test_register_memory_provider_succeeds(self, tmp_path, monkeypatch):
-        """A user plugin calling register_memory_provider() loads without error."""
-        plugins_dir = tmp_path / "hermes_test" / "plugins"
-        self._make_memory_plugin(plugins_dir, "mempalace")
-        monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes_test"))
-
-        mgr = PluginManager()
-        mgr.discover_and_load()
-
-        assert "mempalace" in mgr._plugins
-        assert mgr._plugins["mempalace"].enabled, (
-            mgr._plugins["mempalace"].error
-        )
-
-    def test_plugin_memory_provider_stored(self, tmp_path, monkeypatch):
-        """The provider instance is accessible via get_plugin_memory_provider()."""
-        import hermes_cli.plugins as plugins_mod
-
-        plugins_dir = tmp_path / "hermes_test" / "plugins"
-        self._make_memory_plugin(plugins_dir, "mempalace")
-        monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes_test"))
-
-        mgr = PluginManager()
-        # Swap the singleton so get_plugin_memory_provider() sees our manager
-        monkeypatch.setattr(plugins_mod, "_plugin_manager", mgr)
-        mgr.discover_and_load()
-
-        provider = get_plugin_memory_provider()
-        assert provider is not None
-        assert provider.name == "mempalace"
-
-    def test_second_registration_rejected(self, tmp_path, monkeypatch):
-        """Only one plugin-registered memory provider is accepted."""
-        plugins_dir = tmp_path / "hermes_test" / "plugins"
-        self._make_memory_plugin(plugins_dir, "first_provider")
-        self._make_memory_plugin(plugins_dir, "second_provider")
-        monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes_test"))
-
-        mgr = PluginManager()
-        mgr.discover_and_load()
-
-        # The manager should hold exactly one provider
-        assert mgr._plugin_memory_provider is not None
-        assert mgr._plugin_memory_provider.name in {"first_provider", "second_provider"}
-
-    def test_non_provider_rejected(self, tmp_path, monkeypatch):
-        """Passing a non-MemoryProvider object logs a warning and is ignored."""
-        plugins_dir = tmp_path / "hermes_test" / "plugins"
-        plugin_dir = plugins_dir / "bad_provider"
-        plugin_dir.mkdir(parents=True, exist_ok=True)
-        (plugin_dir / "plugin.yaml").write_text("name: bad_provider\n")
-        (plugin_dir / "__init__.py").write_text(
-            "def register(ctx):\n"
-            "    ctx.register_memory_provider('not-a-provider')\n"
-        )
-        monkeypatch.setenv("HERMES_HOME", str(tmp_path / "hermes_test"))
-
-        mgr = PluginManager()
-        mgr.discover_and_load()
-
-        # Plugin still loads (warning only), but no provider is stored
-        assert mgr._plugin_memory_provider is None

tests/plugins/memory/test_holographic_retrieval.py

@@ -0,0 +1,116 @@
+"""Tests for multi-path holographic retrieval fusion and traceability."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))
+
+from plugins.memory.holographic import HolographicMemoryProvider
+from plugins.memory.holographic.retrieval import FactRetriever, format_benchmark_report
+from plugins.memory.holographic.store import MemoryStore
+
+_FIXTURE_PATH = Path(__file__).resolve().parents[2] / "fixtures" / "holographic_recall_matrix.json"
+
+
+def _fixture() -> dict:
+    return json.loads(_FIXTURE_PATH.read_text())
+
+
+def _seed_store(tmp_path) -> MemoryStore:
+    store = MemoryStore(db_path=tmp_path / "memory_store.db")
+    for fact in _fixture()["facts"]:
+        fact_id = store.add_fact(fact["content"], category=fact["category"], tags=fact.get("tags", ""))
+        if fact.get("updated_at"):
+            store._conn.execute(
+                "UPDATE facts SET created_at = ?, updated_at = ? WHERE fact_id = ?",
+                (fact["updated_at"], fact["updated_at"], fact_id),
+            )
+    store._conn.commit()
+    return store
+
+
+class TestMultiPathRetrieval:
+    def test_lane_toggle_and_trace_contributions(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+
+        payload = retriever.search_with_trace(
+            "Which forge lane does Ezra operate?",
+            limit=3,
+            lanes=["lexical", "graph"],
+        )
+
+        assert payload["trace"]["lanes_run"] == ["lexical", "graph"]
+        assert payload["results"]
+        top = payload["results"][0]
+        assert "BURN2 lane" in top["content"]
+        assert "graph" in top["lane_contributions"]
+        assert set(top["lane_contributions"]).issubset({"lexical", "graph"})
+
+    def test_trace_available_for_failed_recall(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+
+        payload = retriever.search_with_trace(
+            "nonexistent memory topic xyz123",
+            limit=3,
+            lanes=["lexical", "semantic", "graph", "temporal"],
+        )
+
+        assert payload["results"] == []
+        assert payload["trace"]["fused_count"] == 0
+        assert payload["trace"]["lane_hits"]["lexical"] == 0
+        assert payload["trace"]["lane_hits"]["semantic"] == 0
+
+    def test_benchmark_prompt_matrix_shows_gain_over_baseline(self, tmp_path):
+        store = _seed_store(tmp_path)
+        retriever = FactRetriever(store=store)
+        report = retriever.benchmark_prompt_matrix(_fixture()["queries"], limit=3)
+
+        assert report["fused_top1_hits"] > report["baseline_top1_hits"]
+        assert report["improvement"] > 0
+
+        rendered = format_benchmark_report(report)
+        assert "Prompt matrix benchmark" in rendered
+        assert "semantic_alias_graph" in rendered
+        assert "improvement" in rendered.lower()
+
+
+class TestHolographicProviderTrace:
+    def test_prefetch_records_trace_and_trace_action_returns_it(self, tmp_path):
+        provider = HolographicMemoryProvider(
+            config={
+                "db_path": str(tmp_path / "provider.db"),
+                "retrieval_lanes": ["lexical", "semantic", "graph", "temporal"],
+                "enable_rerank": True,
+            }
+        )
+        provider.initialize("test-session")
+
+        seed_store = _seed_store(tmp_path / "seed")
+        rows = seed_store.list_facts(min_trust=0.0, limit=20)
+        for row in rows:
+            provider._store.add_fact(row["content"], category=row["category"], tags=row.get("tags", ""))
+            if row["content"].startswith("The provider is anthropic"):
+                provider._store._conn.execute(
+                    "UPDATE facts SET created_at = ?, updated_at = ? WHERE content = ?",
+                    ("2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z", row["content"]),
+                )
+            elif row["content"].startswith("Correction: the provider is mimo"):
+                provider._store._conn.execute(
+                    "UPDATE facts SET created_at = ?, updated_at = ? WHERE content = ?",
+                    ("2026-04-20T00:00:00Z", "2026-04-20T00:00:00Z", row["content"]),
+                )
+        provider._store._conn.commit()
+
+        block = provider.prefetch("What provider should we use?")
+        assert "Holographic Memory" in block
+        assert "mimo-v2-pro" in block
+
+        trace_payload = json.loads(provider.handle_tool_call("fact_store", {"action": "trace"}))
+        assert trace_payload["trace"]["query"] == "What provider should we use?"
+        assert trace_payload["trace"]["rerank_applied"] in {True, False}
+        assert trace_payload["trace"]["lane_hits"]["temporal"] >= 1