superlocalmemory 3.6.22 → 3.7.0

package/src/superlocalmemory/graph/cozo_backend.py

@@ -51,6 +51,62 @@ class CozoDBQueryError(CozoDBError):
     """Datalog query execution failed."""
 
 
+class _CozoRows:
+    """Small pandas-values compatible view for PyCozo's dict results."""
+
+    def __init__(self, rows: list[list[Any]]) -> None:
+        self._rows = rows
+
+    def tolist(self) -> list[list[Any]]:
+        return self._rows
+
+
+class _CozoResult:
+    """Normalize old PyCozo dict responses to the dataframe surface we use."""
+
+    def __init__(self, result: Any) -> None:
+        self._result = result
+        self.values = _CozoRows(list(result.get("rows", []))) if isinstance(result, dict) else result.values
+
+    def __len__(self) -> int:
+        return len(self.values.tolist())
+
+
+class _CozoClientAdapter:
+    """Bridge PyCozo 0.3 embedded bindings and later client conveniences.
+
+    PyCozo 0.3 is the last client compatible with the published macOS native
+    binding. It returns dictionaries and exposes ``import_relations`` rather
+    than ``put``; later clients return dataframe-like values and add ``put``.
+    SLM only needs relation upserts and row results, so normalize those here.
+    """
+
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def run(self, script: str, params: dict[str, Any] | None = None) -> Any:
+        result = self._client.run(script) if params is None else self._client.run(script, params)
+        return _CozoResult(result) if isinstance(result, dict) else result
+
+    def put(self, relation: str, rows: list[dict[str, Any]]) -> None:
+        if not rows:
+            return
+        put = getattr(self._client, "put", None)
+        if callable(put):
+            put(relation, rows)
+            return
+        headers = list(rows[0])
+        self._client.import_relations({
+            relation: {
+                "headers": headers,
+                "rows": [[row.get(header) for header in headers] for row in rows],
+            },
+        })
+
+    def close(self) -> None:
+        self._client.close()
+
+
 # ---------------------------------------------------------------------------
 # CozoDBGraphBackend
 # ---------------------------------------------------------------------------
@@ -70,7 +126,11 @@ class CozoDBGraphBackend:
         path = Path(db_path)
         path.parent.mkdir(parents=True, exist_ok=True)
         self._db_path = str(path)
-        self._db = _CozoClient("rocksdb", self._db_path)  # type: ignore[misc]
+        client = _CozoClient("rocksdb", self._db_path, dataframe=False)  # type: ignore[misc]
+        self._db = _CozoClientAdapter(client)
+        self._shadow_checks = 0
+        self._shadow_mismatches = 0
+        self._shadow_errors = 0
         self._ensure_schema()
 
     def close(self) -> None:
@@ -100,8 +160,8 @@ class CozoDBGraphBackend:
         try:
             self._db.run("""
                 :create edge {
-                    from_id: String, to_id: String =>
-                    edge_type: String, weight: Float default 1.0,
+                    from_id: String, to_id: String, edge_type: String =>
+                    weight: Float default 1.0,
                     metadata: String default '{}',
                     profile_id: String default 'default',
                     created_at: String
@@ -110,6 +170,21 @@ class CozoDBGraphBackend:
         except Exception:
             pass
 
+        # The entity recall channel resolves a query to canonical entity IDs,
+        # while graph_edges links fact IDs.  Keeping those relations separate
+        # is essential: treating fact IDs as entities produces a healthy but
+        # semantically incompatible graph.  ``fact_entity`` is the bridge
+        # that lets Cozo traverse the same two spaces as the SQLite channel.
+        try:
+            self._db.run("""
+                :create fact_entity {
+                    fact_id: String, entity_id: String =>
+                    profile_id: String default 'default'
+                }
+            """)
+        except Exception:
+            pass
+
     # ------------------------------------------------------------------
     # Write Path
     # ------------------------------------------------------------------
@@ -158,6 +233,60 @@ class CozoDBGraphBackend:
             "created_at": now,
         }])
 
+    def add_fact_entities(
+        self,
+        fact_id: str,
+        entity_ids: list[str],
+        profile_id: str = "default",
+    ) -> None:
+        """Upsert the canonical entities attached to one fact.
+
+        This is deliberately a separate relation from ``edge``.  Fact edges
+        and canonical entity IDs are different namespaces in SLM.
+        """
+        self._db.put("fact_entity", [
+            {"fact_id": fact_id, "entity_id": entity_id, "profile_id": profile_id}
+            for entity_id in dict.fromkeys(entity_ids)
+            if entity_id
+        ])
+
+    def remove_fact(self, fact_id: str) -> None:
+        """Remove a fact's derived graph records using bound query values."""
+        # Cozo :rm needs every non-key column in the output relation.  Binding
+        # ``fact_id`` keeps apostrophes and Datalog syntax in external IDs from
+        # becoming executable query text.
+        self._db.run("""
+            ?[fact_id, entity_id, profile_id] :=
+                *fact_entity{fact_id, entity_id, profile_id}, fact_id = $fact_id
+            :rm fact_entity {fact_id, entity_id => profile_id}
+        """, {"fact_id": fact_id})
+
+    def record_shadow_comparison(
+        self,
+        *,
+        matches: bool,
+        projected: list[tuple[str, float]],
+        canonical: list[tuple[str, float]],
+    ) -> None:
+        """Retain aggregate parity telemetry without persisting recalled text."""
+        self._shadow_checks += 1
+        if not matches:
+            self._shadow_mismatches += 1
+            logger.warning(
+                "Cozo entity recall diverged from canonical SQLite; using SQLite "
+                "(projected=%d canonical=%d)", len(projected), len(canonical),
+            )
+
+    def record_shadow_error(self, error: str) -> None:
+        self._shadow_errors += 1
+        logger.warning("Cozo entity recall failed closed to SQLite: %s", error)
+        self._db.run("""
+            ?[from_id, to_id, edge_type, weight, metadata, profile_id, created_at] :=
+                *edge{from_id, to_id, edge_type, weight, metadata, profile_id, created_at},
+                (from_id = $fact_id or to_id = $fact_id)
+            :rm edge {from_id, to_id, edge_type => weight, metadata, profile_id, created_at}
+        """, {"fact_id": fact_id})
+
     # ------------------------------------------------------------------
     # Bulk Import (SQLite → CozoDB)
     # ------------------------------------------------------------------
@@ -178,37 +307,57 @@ class CozoDBGraphBackend:
         if tier_filter is None:
             tier_filter = ["active", "warm"]
 
-        # Step 1: Export all unique node IDs from graph_edges as entities.
-        # graph_edges uses fact IDs as nodes. canonical_entities uses separate entity IDs.
-        # CozoDB graph mirrors the graph_edges adjacency — node = fact ID.
+        # Step 1: Export canonical entity records.  Do *not* synthesize
+        # entities from graph_edges: those are fact IDs and belong to the
+        # separate fact graph relation below.
         entities_sql = """
-            SELECT DISTINCT node_id FROM (
-                SELECT source_id as node_id FROM graph_edges WHERE profile_id = ?
-                UNION
-                SELECT target_id as node_id FROM graph_edges WHERE profile_id = ?
-            )
+            SELECT entity_id, canonical_name, entity_type, first_seen, last_seen, fact_count
+            FROM canonical_entities WHERE profile_id = ?
         """
-        rows = conn.execute(entities_sql, (profile_id, profile_id)).fetchall()
+        rows = conn.execute(entities_sql, (profile_id,)).fetchall()
 
         entity_dicts = []
         now = datetime.now().isoformat()
-        for (nid,) in rows:
+        for entity_id, name, entity_type, first_seen, last_seen, fact_count in rows:
             entity_dicts.append({
-                "id": nid,
-                "name": nid[:12],
-                "entity_type": "fact_node",
+                "id": entity_id,
+                "name": name,
+                "entity_type": entity_type or "concept",
                 "tier": "active",
-                "properties": "{}",
+                "properties": json.dumps({"fact_count": int(fact_count or 0)}),
                 "profile_id": profile_id,
-                "created_at": now,
-                "updated_at": now,
+                "created_at": first_seen or now,
+                "updated_at": last_seen or now,
             })
 
         if entity_dicts:
             self._db.put("entity", entity_dicts)
         logger.info("CozoDB: imported %d entities", len(entity_dicts))
 
-        # Step 2: Export edges directly (source_id/target_id are fact IDs)
+        # Step 2: Export fact-to-canonical-entity mappings.  This relation is
+        # what allows a canonical query seed to enter the fact graph.
+        facts_sql = """
+            SELECT fact_id, canonical_entities_json
+            FROM atomic_facts WHERE profile_id = ?
+        """
+        fact_entity_dicts: list[dict[str, str]] = []
+        for fact_id, raw_entities in conn.execute(facts_sql, (profile_id,)).fetchall():
+            try:
+                entity_ids = json.loads(raw_entities or "[]")
+            except (TypeError, ValueError, json.JSONDecodeError):
+                entity_ids = []
+            for entity_id in dict.fromkeys(entity_ids):
+                if entity_id:
+                    fact_entity_dicts.append({
+                        "fact_id": fact_id,
+                        "entity_id": str(entity_id),
+                        "profile_id": profile_id,
+                    })
+        if fact_entity_dicts:
+            self._db.put("fact_entity", fact_entity_dicts)
+
+        # Step 3: Export fact graph edges directly.  Fact graph traversal is
+        # intentionally kept in its native fact-ID namespace.
         edges_sql = """
             SELECT source_id, target_id, edge_type, weight
             FROM graph_edges WHERE profile_id = ?
@@ -234,6 +383,83 @@ class CozoDBGraphBackend:
 
         return len(edge_dicts)
 
+    def recall_facts(
+        self,
+        seed_entity_ids: list[str],
+        *,
+        profile_id: str = "default",
+        depth: int = 4,
+        decay: float = 0.7,
+        threshold: float = 0.05,
+        top_k: int = 50,
+    ) -> list[tuple[str, float]]:
+        """Mirror SLM's entity-to-fact/fact-graph activation in Cozo storage.
+
+        Query values never enter Datalog source.  Cozo is used as the durable
+        projection; activation runs in Python so the algorithm stays aligned
+        with the SQLite in-memory channel and can be shadow-compared exactly.
+        """
+        if not seed_entity_ids:
+            return []
+        entity_rows = self._db.run(
+            "?[fact_id, entity_id] := *fact_entity{fact_id, entity_id, profile_id}, profile_id = $profile_id",
+            {"profile_id": profile_id},
+        )
+        edge_rows = self._db.run(
+            "?[from_id, to_id, weight] := *edge{from_id, to_id, weight, profile_id}, profile_id = $profile_id",
+            {"profile_id": profile_id},
+        )
+        entity_to_facts: dict[str, list[str]] = {}
+        fact_to_entities: dict[str, list[str]] = {}
+        for fact_id, entity_id in entity_rows.values.tolist() if len(entity_rows) else []:
+            entity_to_facts.setdefault(str(entity_id), []).append(str(fact_id))
+            fact_to_entities.setdefault(str(fact_id), []).append(str(entity_id))
+        adjacency: dict[str, list[tuple[str, float]]] = {}
+        for source_id, target_id, weight in edge_rows.values.tolist() if len(edge_rows) else []:
+            source, target = str(source_id), str(target_id)
+            # Match EntityGraphChannel: graph edges are bidirectional during
+            # activation even when stored as directed rows.
+            adjacency.setdefault(source, []).append((target, float(weight)))
+            adjacency.setdefault(target, []).append((source, float(weight)))
+
+        activation: dict[str, float] = {}
+        visited_entities = set(seed_entity_ids)
+        for entity_id in seed_entity_ids:
+            for fact_id in entity_to_facts.get(entity_id, ()):
+                activation[fact_id] = max(activation.get(fact_id, 0.0), 1.0)
+        frontier = set(activation)
+        for hop in range(1, depth):
+            hop_decay = decay ** hop
+            if hop_decay < threshold:
+                break
+            next_frontier: set[str] = set()
+            for fact_id in frontier:
+                for neighbor_id, _weight in adjacency.get(fact_id, ()):
+                    # SQLite intentionally ignores edge weights when graph
+                    # metrics are unavailable; use that same baseline here.
+                    score = activation[fact_id] * decay
+                    if score >= threshold and score > activation.get(neighbor_id, 0.0):
+                        activation[neighbor_id] = score
+                        next_frontier.add(neighbor_id)
+            for fact_id in frontier:
+                for entity_id in fact_to_entities.get(fact_id, ()):
+                    if entity_id in visited_entities:
+                        continue
+                    visited_entities.add(entity_id)
+                    for related_fact_id in entity_to_facts.get(entity_id, ()):
+                        if hop_decay > activation.get(related_fact_id, 0.0):
+                            activation[related_fact_id] = hop_decay
+                            next_frontier.add(related_fact_id)
+            frontier = next_frontier
+            if not frontier:
+                break
+        results = [(fact_id, score) for fact_id, score in activation.items() if score >= threshold]
+        if not results:
+            return []
+        maximum = max(score for _, score in results)
+        results = [(fact_id, score / maximum) for fact_id, score in results]
+        return sorted(results, key=lambda item: item[1], reverse=True)[:top_k]
+
     # ------------------------------------------------------------------
     # Spreading Activation (Python BFS over CozoDB edges)
     # ------------------------------------------------------------------
@@ -267,10 +493,10 @@ class CozoDBGraphBackend:
             for entity_id in current_frontier:
                 # Query all outgoing edges from this entity
                 try:
-                    result = self._db.run(f"""
+                    result = self._db.run("""
                         ?[to_id, weight] :=
-                            *edge{{from_id: '{entity_id}', to_id, weight}}
-                    """)
+                            *edge{from_id, to_id, weight}, from_id = $entity_id
+                    """, {"entity_id": entity_id})
                     df = result if hasattr(result, "values") else result
                     if df is None or len(df) == 0:
                         continue
@@ -497,6 +723,9 @@ class CozoDBGraphBackend:
                 "status": "active",
                 "entities": int(ec),
                 "edges": int(edc),
+                "shadow_checks": self._shadow_checks,
+                "shadow_mismatches": self._shadow_mismatches,
+                "shadow_errors": self._shadow_errors,
                 "db_path": self._db_path,
             }
         except Exception as exc:
@@ -522,6 +751,10 @@ class CozoDBGraphBackend:
             self._db.run("::remove edge")
         except Exception:
             pass
+        try:
+            self._db.run("::remove fact_entity")
+        except Exception:
+            pass
 
         self._ensure_schema()
         return self.bulk_import_from_sqlite(conn, profile_id)

package/src/superlocalmemory/hooks/_outcome_common.py

@@ -36,7 +36,6 @@ import time
 from pathlib import Path
 from typing import IO, Optional
 
-
 # ---------------------------------------------------------------------------
 # Budget constants
 # ---------------------------------------------------------------------------
@@ -63,17 +62,19 @@ PERF_LOG_CHECK_EVERY: int = 256  # check size every N writes, not every write
 
 
 def slm_home() -> Path:
-    """Return ``~/.superlocalmemory`` honouring ``SLM_HOME`` override.
+    """Return the canonical runtime-state root for outcome hooks.
 
-    ``SLM_HOME`` exists solely so unit tests can isolate filesystem state.
-    Production code sets nothing and falls back to the home-directory path.
+    The central resolver owns environment alias precedence. Keeping that
+    policy out of this hot-path module prevents hooks from silently selecting
+    a different database than the daemon or MCP server.
 
     SEC-M6 — first-creation chmod's the dir to 0700 so the audit marker
     in ``ram_lock.sem`` (``{pid}:{name}``) and session-state files are
     not world-readable on shared hosts.
     """
-    override = os.environ.get("SLM_HOME", "").strip()
-    base = Path(override) if override else (Path.home() / ".superlocalmemory")
+    from superlocalmemory.infra.data_root import canonical_data_root
+
+    base = canonical_data_root()
     try:
         if not base.exists():
             base.mkdir(parents=True, exist_ok=True)
@@ -266,7 +267,7 @@ _PERF_LOG_FD: Optional[IO[str]] = None
 _PERF_LOG_PATH: Optional[Path] = None
 # S9-W3 M-PERF-02: RLock (not Lock) so a reentrant acquire during
 # atexit shutdown — e.g. a handler that calls ``log_perf`` while
-# ``_perf_log_flush`` already holds the lock — does not deadlock
+# ``close_perf_log`` already holds the lock — does not deadlock
 # the interpreter for the 30s graceful-shutdown timeout.
 _PERF_LOG_LOCK = threading.RLock()
 _PERF_LOG_WRITE_COUNT: int = 0  # SEC-M4 — rotation cadence counter
@@ -340,8 +341,12 @@ def _maybe_rotate_perf_log(path: Path) -> None:
         pass
 
 
-def _perf_log_flush() -> None:
-    """Flush the cached perf log fd (atexit hook). Never raises."""
+def close_perf_log() -> None:
+    """Flush and close the process-owned perf-log stream. Never raises.
+
+    Long-lived hosts and isolated tests can call this at their lifecycle
+    boundary; the atexit registration remains the final safety net.
+    """
     global _PERF_LOG_FD
     with _PERF_LOG_LOCK:
         fd = _PERF_LOG_FD
@@ -358,7 +363,12 @@ def _perf_log_flush() -> None:
         pass
 
 
-atexit.register(_perf_log_flush)
+def _perf_log_flush() -> None:
+    """Backward-compatible private alias for existing daemon shutdown code."""
+    close_perf_log()
+
+
+atexit.register(close_perf_log)
 
 
 #: S9-W3 C8: rotation flag set on hot path, drained on exit / next
@@ -407,7 +417,7 @@ def log_perf(hook_name: str, duration_ms: float, outcome: str) -> None:
 
     Best-effort: disk full / unwritable dir → silently skip. Uses a
     module-level append-only fd opened on first use and flushed on
-    process exit via :func:`_perf_log_flush`.
+    process exit via :func:`close_perf_log`.
 
     S9-W3 C8: the rotation/rename/reopen workflow has moved OFF the
     hot-path lock. Previously every 256th call held the lock across

package/src/superlocalmemory/hooks/antigravity_adapter.py

@@ -35,15 +35,11 @@ from superlocalmemory.hooks.adapter_base import (
     truncate_to_cap,
 )
 from superlocalmemory.hooks.context_payload import (
+    VERSION,
     ContextPayload,
     RecallFn,
-    build_payload,
-    format_decisions,
-    format_entities,
-    format_memories,
-    format_topics,
-    truncate_payload_for_cap,
 )
+from superlocalmemory.hooks.memory_protocol import memory_protocol_markdown
 
 logger = logging.getLogger(__name__)
 
@@ -63,30 +59,21 @@ GLOBAL_REL = f".gemini/antigravity/{_SKILLS}/{_GLOBAL_SKILL_NAME}/SKILL.md"
 _FRONTMATTER = (
     "---\n"
     "name: slm-memory-adapter\n"
-    "description: \"Surfaces SuperLocalMemory context "
-    "(topics, entities, decisions) at the start of every "
-    "Antigravity conversation.\"\n"
+    "description: \"SuperLocalMemory runtime MCP memory protocol.\"\n"
     "---\n"
 )
 
 _BODY_TEMPLATE = (
-    "\n# SLM Memory Adapter\n\n"
-    "_Auto-generated by SuperLocalMemory v{version}. Last sync: {generated_at}._\n\n"
-    "## Preferences\n{topics}\n\n"
-    "## Entities\n{entities}\n\n"
-    "## Recent decisions\n{decisions}\n\n"
-    "## Project memories\n{memories}\n"
+    "\n# SLM Runtime Memory Protocol\n\n"
+    "_Managed by SuperLocalMemory v{version}. This skill contains no recalled memory._\n\n"
+    "{protocol}"
 )
 
 
-def render_antigravity(payload: ContextPayload) -> bytes:
+def render_antigravity(payload: ContextPayload | None = None) -> bytes:
     body = _BODY_TEMPLATE.format(
-        version=payload.version,
-        generated_at=payload.generated_at,
-        topics=format_topics(payload),
-        entities=format_entities(payload),
-        decisions=format_decisions(payload),
-        memories=format_memories(payload),
+        version=payload.version if payload is not None else VERSION,
+        protocol=memory_protocol_markdown(),
     )
     return (_FRONTMATTER + body).encode("utf-8")
 
@@ -144,15 +131,7 @@ class AntigravityAdapter:
             self._inactive_until_retry = True
             return False
 
-        # For builder purposes, treat workspace scope as project.
-        scope_for_builder = "project" if self._scope == "workspace" else "global"
-        payload = build_payload(
-            self._profile_id, scope_for_builder, self._base_dir,
-            recall_fn=self._recall_fn,
-        )
-        rendered = truncate_payload_for_cap(
-            payload, hard_cap=HARD_BYTES_CAP, render=render_antigravity,
-        )
+        rendered = render_antigravity()
         rendered = truncate_to_cap(rendered, cap=HARD_BYTES_CAP)
 
         result: WriteResult = atomic_write(

package/src/superlocalmemory/hooks/auto_invoker.py

@@ -21,11 +21,11 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
-import json
 import logging
 import math
 
 from superlocalmemory.core.config import AutoInvokeConfig
+from superlocalmemory.core.injection import InjectableMemory, render_context
 
 logger = logging.getLogger(__name__)
 
@@ -90,16 +90,19 @@ class AutoInvoker:
                 limit=self._config.max_memories_injected,
             )
 
-            memory_context = self.format_for_injection(results) if results else ""
-
-            # V3.3: Inject soft prompts (priority over memory context)
             soft_prompt_text = self._get_soft_prompt_text()
-            if soft_prompt_text and self._prompt_injector is not None:
-                return self._prompt_injector.inject_into_context(
-                    soft_prompt_text, memory_context,
-                )
-
-            return soft_prompt_text + ("\n\n" + memory_context if memory_context else "") if soft_prompt_text else memory_context
+            if soft_prompt_text:
+                results = [
+                    {
+                        "fact_id": "",
+                        "content": soft_prompt_text,
+                        "fact_type": "behavioral-pattern",
+                        "score": 0.0,
+                        "contextual_description": "",
+                    },
+                    *results,
+                ]
+            return self.format_for_injection(results) if results else ""
         except Exception as exc:
             logger.debug("Auto-invoke failed: %s", exc)
             return ""
@@ -476,29 +479,24 @@ class AutoInvoker:
     # ------------------------------------------------------------------
 
     def format_for_injection(self, results: list[dict]) -> str:
-        """Format results for system prompt injection.
-
-        Output: Markdown list with content previews and context.
-        """
+        """Format results as bounded, untrusted evidence with provenance."""
         if not results:
             return ""
 
-        lines = ["# Relevant Memory Context", ""]
+        memories: list[InjectableMemory] = []
         for r in results:
-            content_preview = r["content"][:200]
+            content = str(r.get("content", ""))
             ctx = r.get("contextual_description", "")
-
-            line = f"- [{r['fact_type']}] {content_preview}"
             if ctx:
-                line += f"\n  > Context: {ctx}"
-            lines.append(line)
-
-        lines.append("")
-        lines.append(
-            f"_Auto-invoked {len(results)} memories "
-            f"(FOK >= {self._config.fok_threshold})_"
-        )
-        return "\n".join(lines)
+                content += f"\nContext: {ctx}"
+            memories.append(InjectableMemory(
+                content=content,
+                score=float(r.get("score", 0.0) or 0.0),
+                fact_id=str(r.get("fact_id", "")),
+                source_type=str(r.get("fact_type", "auto-invoke")),
+                source_id=f"fok-threshold:{self._config.fok_threshold}",
+            ))
+        return render_context(memories, mode="B", cfg=None, wrap=True)
 
     # ------------------------------------------------------------------
     # V3.3: Soft prompt injection

package/src/superlocalmemory/hooks/auto_recall.py

@@ -9,6 +9,8 @@ from __future__ import annotations
 import logging
 from typing import Any, Callable
 
+from superlocalmemory.core.injection import InjectableMemory, render_context
+
 logger = logging.getLogger(__name__)
 
 
@@ -72,12 +74,18 @@ class AutoRecall:
             if not relevant:
                 return ""
 
-            # Format for injection
-            lines = ["# Relevant Memory Context", ""]
-            for r in relevant[:self._max_memories]:
-                lines.append(f"- {r.fact.content[:200]}")
-
-            return "\n".join(lines)
+            memories = [
+                InjectableMemory(
+                    content=r.fact.content,
+                    score=float(r.score),
+                    fact_id=str(r.fact.fact_id),
+                    importance=float(getattr(r.fact, "importance", 0.0) or 0.0),
+                    access_count=int(getattr(r.fact, "access_count", 0) or 0),
+                    source_type="recall",
+                )
+                for r in relevant[:self._max_memories]
+            ]
+            return render_context(memories, mode="B", cfg=None, wrap=True)
         except Exception as exc:
             logger.warning("Auto-recall failed: %s", exc)
             return ""
@@ -103,6 +111,23 @@ class AutoRecall:
                         "fact_id": r.fact.fact_id,
                         "content": r.fact.content[:300],
                         "score": round(r.score, 3),
+                        "relevance_score": round(
+                            getattr(r, "relevance_score", r.score) or 0.0, 3
+                        ),
+                        "ranking_score": getattr(r, "ranking_score", None),
+                        "confidence": round(
+                            getattr(
+                                r, "memory_confidence",
+                                getattr(r, "confidence", 0.0),
+                            ) or 0.0, 3
+                        ),
+                        "memory_confidence": round(
+                            getattr(
+                                r, "memory_confidence",
+                                getattr(r, "confidence", 0.0),
+                            ) or 0.0, 3
+                        ),
+                        "rank_position": int(getattr(r, "rank_position", 0) or 0),
                     })
             return results
         except Exception as exc: