superlocalmemory 3.6.23 → 3.7.0

package/src/superlocalmemory/mcp/tools_core.py

@@ -13,25 +13,24 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import hashlib
 import logging
-from pathlib import Path
 from typing import Callable
 
 from mcp.types import ToolAnnotations
 
 from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+from superlocalmemory.infra.data_root import canonical_data_root, state_path
+from superlocalmemory.mcp.shared import authorize_mcp_mutation
 
 logger = logging.getLogger(__name__)
 
-_DB_PATH = str(Path.home() / ".superlocalmemory" / "memory.db")
-
-
 def _emit_event(event_type: str, payload: dict | None = None,
                 source_agent: str = "mcp_client") -> None:
     """Emit an event to the EventBus (best-effort, never raises)."""
     try:
         from superlocalmemory.infra.event_bus import EventBus
-        bus = EventBus.get_instance(_DB_PATH)
+        bus = EventBus.get_instance(str(state_path("memory.db")))
         bus.emit(event_type, payload=payload, source_agent=source_agent,
                  source_protocol="mcp")
     except Exception:
@@ -58,7 +57,6 @@ def _record_recall_hits(
     signal quality is never load-bearing on recall correctness.
     """
     try:
-        from pathlib import Path
         from superlocalmemory.learning.signals import (
             LearningSignals,
             enqueue_shown_flip,
@@ -66,7 +64,7 @@ def _record_recall_hits(
 
         engine = get_engine()
         pid = engine.profile_id
-        slm_dir = Path.home() / ".superlocalmemory"
+        slm_dir = canonical_data_root()
 
         shown_ids = [r.get("fact_id", "") for r in results[:10]
                      if r.get("fact_id")]
@@ -108,6 +106,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         agent_id: str = "mcp_client",
         scope: str | None = None,
         shared_with: str = "",
+        idempotency_key: str = "",
     ) -> dict:
         """Store content to memory with intelligent indexing.
 
@@ -128,13 +127,22 @@ def register_core_tools(server, get_engine: Callable) -> None:
             "agent_id": agent_id,
             "session_id": session_id,
         }
+        effective_idempotency_key = idempotency_key
+        if not effective_idempotency_key and session_id:
+            material = (
+                f"{agent_id}\0{session_id}\0{scope or ''}\0{shared_with}\0{content}"
+            )
+            effective_idempotency_key = "mcp:" + hashlib.sha256(
+                material.encode("utf-8")
+            ).hexdigest()
         # Parse shared_with from comma-separated string
         _shared_list = [s.strip() for s in shared_with.split(",") if s.strip()] if shared_with else None
         # v3.5.5 WRITE-THROUGH: route through the daemon's /remember, which does
         # a synchronous verbatim insert (memory is keyword/BM25-recallable the
         # instant this returns) and enqueues async enrichment. This closes the
         # recall window so a parallel/next agent finds memories saved seconds ago.
-        # Falls back to pending.db only if the daemon is unreachable.
+        # Falls back to the capability-owned worker only if the daemon is
+        # unreachable. Raw pending.db writes are legacy replay input only.
         try:
             import asyncio as _asyncio
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
@@ -145,36 +153,87 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 resp = await _asyncio.to_thread(daemon_request, "POST", "/remember", {
                     "content": content, "tags": tags, "metadata": meta,
                     "scope": scope, "shared_with": _shared_list,
+                    "session_id": session_id,
+                    "idempotency_key": effective_idempotency_key or None,
                 })
                 if resp and (resp.get("fact_ids") is not None or resp.get("ok")):
                     fids = resp.get("fact_ids") or []
+                    materialization_state = resp.get("materialization_state")
+                    if materialization_state is None:
+                        materialization_state = (
+                            "complete" if resp.get("status") == "stored" else "queryable"
+                        )
+                    pending = materialization_state != "complete"
                     return {
                         "success": True,
-                        "fact_ids": fids or [f"pending:{resp.get('pending_id','')}"],
-                        "count": len(fids) if fids else 1,
-                        "pending": not fids,
-                        "message": "Stored (recallable now; enriching async).",
+                        "fact_ids": fids,
+                        "count": int(resp.get("count", len(fids))),
+                        "pending": pending,
+                        "pending_id": resp.get("pending_id") if pending else None,
+                        "operation_id": resp.get("operation_id"),
+                        "materialization_state": materialization_state,
+                        "message": (
+                            "Stored through canonical daemon ingestion."
+                            if not pending
+                            else "Queryable now; canonical enrichment is still running."
+                        ),
                     }
         except Exception as dexc:
             logger.debug("MCP remember via daemon failed, pending fallback: %s", dexc)
 
         try:
-            from superlocalmemory.cli.pending_store import store_pending
-            # v3.6.15: preserve a non-personal scope through the offline path so
-            # the materializer replays the right visibility (else --scope global
-            # would silently downgrade to personal when the daemon is offline).
-            if scope and scope != "personal":
-                meta = {**meta, "scope": scope}
-                if _shared_list:
-                    meta["shared_with"] = _shared_list
-            pending_id = store_pending(content, tags=tags, metadata=meta)
+            import asyncio as _asyncio
+            from superlocalmemory.mcp._daemon_proxy import choose_pool
+
+            worker_meta = {
+                **meta,
+                "tags": tags,
+                "scope": scope or "personal",
+                "shared_with": _shared_list or [],
+                "idempotency_key": (
+                    effective_idempotency_key
+                    or "mcp:" + hashlib.sha256(content.encode("utf-8")).hexdigest()
+                ),
+            }
+            stored = await _asyncio.to_thread(
+                choose_pool().store,
+                content,
+                worker_meta,
+            )
+            if not isinstance(stored, dict) or not stored.get("ok"):
+                raise RuntimeError(
+                    (stored or {}).get("error", "canonical worker store failed")
+                    if isinstance(stored, dict)
+                    else "canonical worker returned an invalid response"
+                )
+            fact_ids = list(stored.get("fact_ids") or [])
+            materialization_state = str(
+                stored.get("materialization_state") or "complete"
+            )
+            allowed_states = {"queryable", "enriching", "complete"}
+            if materialization_state not in allowed_states:
+                raise RuntimeError(
+                    "canonical worker returned invalid materialization state: "
+                    f"{materialization_state}"
+                )
+            pending = materialization_state != "complete"
+            operation_id = stored.get("operation_id")
+            pending_id = stored.get("pending_id")
+            if pending and pending_id is None:
+                pending_id = operation_id
             return {
                 "success": True,
-                "fact_ids": [f"pending:{pending_id}"],
-                "count": 1,
-                "pending": True,
-                "pending_id": pending_id,
-                "message": "Stored — facts will appear shortly (daemon offline).",
+                "fact_ids": fact_ids,
+                "count": int(stored.get("count", len(fact_ids))),
+                "pending": pending,
+                "pending_id": pending_id if pending else None,
+                "operation_id": operation_id,
+                "materialization_state": materialization_state,
+                "message": (
+                    "Stored through canonical local ingestion."
+                    if not pending
+                    else "Queryable now; canonical enrichment is still running."
+                ),
             }
         except Exception as exc:
             logger.exception("remember failed")
@@ -277,6 +336,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     "retrieval_time_ms": result.get("retrieval_time_ms", 0),
                     # v3.6.6: surface evidence-floor signal to MCP clients.
                     "no_confident_match": result.get("no_confident_match", False),
+                    "score_contract_version": result.get("score_contract_version", "2"),
+                    "calibration_status": result.get("calibration_status", "uncalibrated"),
+                    "calibration_id": result.get("calibration_id"),
+                    "answer_confidence": result.get("answer_confidence"),
+                    "abstained": result.get("abstained", False),
+                    "abstention_reason": result.get("abstention_reason"),
                 }
             return {"success": False, "error": result.get("error", "Recall failed")}
         except Exception as exc:
@@ -403,12 +468,19 @@ def register_core_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             pid = profile_id or engine.profile_id
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-build-memory-graph",
+                profile_id=pid,
+            )
             facts = engine._db.get_all_facts(pid)
             edge_count = 0
             for fact in facts:
                 if engine._graph_builder:
                     engine._graph_builder.build_edges(fact, pid)
                     edge_count += 1
+            authorization.complete()
             return {
                 "success": True,
                 "facts_processed": len(facts),
@@ -424,6 +496,13 @@ def register_core_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             old = engine.profile_id
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-switch-profile",
+                profile_id=profile_id,
+                content_preview=f"{old} -> {profile_id}",
+            )
             engine.profile_id = profile_id
 
             # Persist to both config stores so CLI and Dashboard stay in sync
@@ -446,6 +525,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             except Exception:
                 logger.debug("worker-pool recycle on profile switch skipped")
 
+            authorization.complete()
             return {
                 "success": True,
                 "previous_profile": old,
@@ -513,6 +593,14 @@ def register_core_tools(server, get_engine: Callable) -> None:
         """Correct or annotate a learned behavioral pattern to improve retrieval."""
         try:
             engine = get_engine()
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-correct-pattern",
+                profile_id=engine.profile_id,
+                fact_id=pattern_id,
+                content_preview=correction,
+            )
             from superlocalmemory.learning.behavioral import BehavioralPatternStore
             store = BehavioralPatternStore(engine._db.db_path)
             store.record(
@@ -521,6 +609,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 pattern_key=pattern_id,
                 metadata={"correction": correction},
             )
+            authorization.complete()
             return {"success": True, "pattern_id": pattern_id}
         except Exception as exc:
             logger.exception("correct_pattern failed")
@@ -548,7 +637,9 @@ def register_core_tools(server, get_engine: Callable) -> None:
             result = pool._send({
                 "cmd": "delete_memory",
                 "fact_id": fact_id,
-                "agent_id": agent_id,
+                # Informational IDE/client label only.  The worker derives its
+                # authorization actor from the private local capability.
+                "source_agent_id": agent_id,
             })
             if result.get("ok"):
                 logger.info("Memory deleted: %s by agent: %s", fact_id[:16], agent_id)
@@ -589,7 +680,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 "cmd": "update_memory",
                 "fact_id": fact_id,
                 "content": content.strip(),
-                "agent_id": agent_id,
+                "source_agent_id": agent_id,
             })
             if result.get("ok"):
                 logger.info("Memory updated: %s by agent: %s", fact_id[:16], agent_id)
@@ -607,7 +698,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             "product": "SuperLocalMemory V3",
             "author": "Varun Pratap Bhardwaj",
             "organization": "Qualixar",
-            "license": "Elastic-2.0",
+            "license": "AGPL-3.0-or-later",
             "urls": {
                 "product": "https://superlocalmemory.com",
                 "author": "https://varunpratap.com",
@@ -627,6 +718,14 @@ def _format_results(results) -> list[dict]:
             "content": r.fact.content,
             "score": round(r.score, 3),
             "confidence": round(r.confidence, 3),
+            "relevance_score": round(
+                getattr(r, "relevance_score", r.score) or 0.0, 3
+            ),
+            "ranking_score": getattr(r, "ranking_score", None),
+            "memory_confidence": round(
+                getattr(r, "memory_confidence", r.confidence) or 0.0, 3
+            ),
+            "rank_position": int(getattr(r, "rank_position", 0) or 0),
             "trust_score": round(r.trust_score, 3),
             "fact_type": r.fact.fact_type.value,
             "channel_scores": {

package/src/superlocalmemory/mcp/tools_evolution.py

@@ -22,12 +22,10 @@ from pathlib import Path
 from typing import Callable
 
 from mcp.types import ToolAnnotations
+from superlocalmemory.infra.data_root import state_path
 
 logger = logging.getLogger(__name__)
 
-MEMORY_DB = Path.home() / ".superlocalmemory" / "memory.db"
-
-
 def register_evolution_tools(server, get_engine: Callable) -> None:
     """Register evolution MCP tools for skill evolution intelligence."""
 
@@ -49,7 +47,7 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
         """
         try:
             # Check if evolution is enabled in config
-            config_path = Path.home() / ".superlocalmemory" / "config.json"
+            config_path = state_path("config.json")
             evo_cfg = {}
             if config_path.exists():
                 with open(config_path) as f:
@@ -82,7 +80,7 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
             class _Cfg:
                 evolution = _EvoCfg()
 
-            db_path = str(MEMORY_DB)
+            db_path = str(state_path("memory.db"))
             evolver = SkillEvolver(db_path, _Cfg())
 
             # Build candidate from manual trigger
@@ -145,7 +143,7 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
         try:
             engine = get_engine()
             profile_id = engine.profile_id if engine else "default"
-            db_path = str(MEMORY_DB)
+            db_path = str(state_path("memory.db"))
 
             conn = sqlite3.connect(db_path, timeout=10)
             conn.row_factory = sqlite3.Row
@@ -273,7 +271,7 @@ def register_evolution_tools(server, get_engine: Callable) -> None:
             skill_name: Specific skill name (empty = all skills)
         """
         try:
-            db_path = str(MEMORY_DB)
+            db_path = str(state_path("memory.db"))
             conn = sqlite3.connect(db_path, timeout=10)
             conn.row_factory = sqlite3.Row
 

package/src/superlocalmemory/mcp/tools_learning.py

@@ -24,6 +24,8 @@ from typing import Callable
 
 from mcp.types import ToolAnnotations
 
+from superlocalmemory.mcp.shared import authorize_mcp_mutation
+
 logger = logging.getLogger(__name__)
 
 _MAX_SUMMARY_LEN = 500  # Truncate input/output summaries
@@ -69,6 +71,13 @@ def register_learning_tools(server, get_engine: Callable) -> None:
         output_clean = _scrub(output_summary[:_MAX_SUMMARY_LEN])
 
         try:
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-log-tool-event",
+                profile_id=engine.profile_id,
+                content_preview=tool_name,
+            )
             engine._db.execute(
                 "INSERT INTO tool_events "
                 "(session_id, profile_id, project_path, tool_name, event_type, "
@@ -77,6 +86,7 @@ def register_learning_tools(server, get_engine: Callable) -> None:
                 (session_id, engine.profile_id, project_path, tool_name,
                  event_type, input_clean, output_clean, duration_ms, metadata, now),
             )
+            authorization.complete()
             return {"success": True, "tool": tool_name, "event": event_type}
         except Exception as exc:
             logger.debug("log_tool_event failed: %s", exc)
@@ -144,7 +154,22 @@ def register_learning_tools(server, get_engine: Callable) -> None:
             assertion_id: The assertion ID to reinforce
         """
         engine = get_engine()
-        return _update_assertion_confidence(engine._db, assertion_id, reinforce=True)
+        try:
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-reinforce-assertion",
+                profile_id=engine.profile_id,
+                fact_id=assertion_id,
+            )
+            result = _update_assertion_confidence(
+                engine._db, assertion_id, reinforce=True,
+            )
+            if result.get("success"):
+                authorization.complete()
+            return result
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
 
     @server.tool(annotations=ToolAnnotations(idempotentHint=True))
     async def contradict_assertion(assertion_id: str) -> dict:
@@ -157,7 +182,22 @@ def register_learning_tools(server, get_engine: Callable) -> None:
             assertion_id: The assertion ID to contradict
         """
         engine = get_engine()
-        return _update_assertion_confidence(engine._db, assertion_id, reinforce=False)
+        try:
+            authorization = authorize_mcp_mutation(
+                engine,
+                "delete",
+                mutation_source="mcp-contradict-assertion",
+                profile_id=engine.profile_id,
+                fact_id=assertion_id,
+            )
+            result = _update_assertion_confidence(
+                engine._db, assertion_id, reinforce=False,
+            )
+            if result.get("success"):
+                authorization.complete()
+            return result
+        except Exception as exc:
+            return {"success": False, "error": str(exc)}
 
 
 def _update_assertion_confidence(db, assertion_id: str, reinforce: bool) -> dict:

package/src/superlocalmemory/mcp/tools_mesh.py

@@ -17,7 +17,6 @@ Auto-heartbeat keeps the session alive as long as the MCP server is running.
 from __future__ import annotations
 
 import asyncio
-import json
 import logging
 import os
 import threading
@@ -38,18 +37,6 @@ _HEARTBEAT_THREAD: threading.Thread | None = None
 _REGISTERED = False
 
 
-def _daemon_url() -> str:
-    """Get the daemon base URL."""
-    port = 8765
-    try:
-        port_file = os.path.join(os.path.expanduser("~"), ".superlocalmemory", "daemon.port")
-        if os.path.exists(port_file):
-            port = int(open(port_file).read().strip())
-    except Exception:
-        pass
-    return f"http://127.0.0.1:{port}"
-
-
 def _detect_project_path() -> str:
     """Detect current project path from env or cwd."""
     return (
@@ -60,15 +47,11 @@ def _detect_project_path() -> str:
 
 
 def _mesh_request(method: str, path: str, body: dict | None = None) -> dict | None:
-    """Send request to daemon mesh broker."""
-    import urllib.request
-    url = f"{_daemon_url()}/mesh{path}"
+    """Send an exact-instance, capability-authenticated mesh request."""
     try:
-        data = json.dumps(body).encode() if body else None
-        headers = {"Content-Type": "application/json"} if data else {}
-        req = urllib.request.Request(url, data=data, headers=headers, method=method)
-        resp = urllib.request.urlopen(req, timeout=10)
-        return json.loads(resp.read().decode())
+        from superlocalmemory.cli.daemon import daemon_request
+
+        return daemon_request(method, f"/mesh{path}", body)
     except Exception as exc:
         logger.debug("Mesh request failed: %s %s — %s", method, path, exc)
         return None
@@ -232,8 +215,9 @@ def register_mesh_tools(server, get_engine: Callable) -> None:
     async def mesh_state(key: str = "", value: str = "", action: str = "get") -> dict:
         """Get or set shared state across all sessions.
 
-        Shared state is visible to all peers. Use for coordinating work:
-        server IPs, API keys, feature flags, task assignments.
+        Shared state is visible to authenticated peers. Use it for non-secret
+        coordination metadata such as feature flags and task assignments.
+        Credentials, tokens, passwords, and API keys are rejected.
 
         Args:
             key: State key name

package/src/superlocalmemory/mcp/tools_optimize.py

@@ -219,10 +219,17 @@ def register_optimize_tools(server) -> None:
             norm_tid = _normalize_tenant_id(tenant)
             ttl_exp = time.time() + ttl_seconds
 
-            CacheDB.get_default().set(
+            db = CacheDB.get_default()
+            db.set(
                 cache_key, norm_tid, value_bytes,
                 model="mcp-kv", ttl_expires=ttl_exp, tags=["mcp-kv"],
             )
+            # ``tag_json`` is descriptive only; tag invalidation joins the
+            # normalized llmcache_tags index.  CacheManager registers that
+            # index itself, whereas this direct MCP KV surface writes to
+            # CacheDB.  Register it here so ``slm cache invalidate --tag
+            # mcp-kv`` actually removes entries created by slm_cache_set.
+            db.tag_register(cache_key, norm_tid, ["mcp-kv"])
             return {"ok": True, "stored": True, "note": None}
 
         except Exception as exc:

package/src/superlocalmemory/mcp/tools_v28.py

@@ -15,6 +15,8 @@ from __future__ import annotations
 import logging
 from typing import Callable
 
+from superlocalmemory.mcp.shared import authorize_mcp_mutation
+
 logger = logging.getLogger(__name__)
 
 
@@ -42,6 +44,11 @@ def register_v28_tools(server, get_engine: Callable) -> None:
         """
         try:
             engine = get_engine()
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-report-outcome",
+            )
             from superlocalmemory.learning.outcomes import OutcomeTracker
             tracker = OutcomeTracker(engine._db)
             ids = [mid.strip() for mid in memory_ids.split(",") if mid.strip()]
@@ -58,8 +65,8 @@ def register_v28_tools(server, get_engine: Callable) -> None:
             # Previously, outcomes were stored but never created learning signals.
             try:
                 from superlocalmemory.learning.feedback import FeedbackCollector
-                from pathlib import Path as _Path
-                learning_db = _Path.home() / ".superlocalmemory" / "learning.db"
+                from superlocalmemory.infra.data_root import state_path
+                learning_db = state_path("learning.db")
                 collector = FeedbackCollector(learning_db)
                 signal_map = {"success": ("user_positive", 1.0),
                               "failure": ("user_negative", 0.0),
@@ -75,6 +82,7 @@ def register_v28_tools(server, get_engine: Callable) -> None:
             except Exception as exc2:
                 logger.debug("Outcome→signal bridge: %s", exc2)
 
+            authorization.complete()
             return {"success": True, "outcome_id": ao.outcome_id, "outcome": outcome}
         except Exception as exc:
             logger.exception("report_outcome failed")
@@ -134,8 +142,14 @@ def register_v28_tools(server, get_engine: Callable) -> None:
         """
         try:
             engine = get_engine()
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-retention-policy",
+            )
             engine._db.set_config("retention_cold_days", str(cold_after_days))
             engine._db.set_config("retention_archive_days", str(archive_after_days))
+            authorization.complete()
             return {
                 "success": True,
                 "cold_after_days": cold_after_days,
@@ -174,10 +188,17 @@ def register_v28_tools(server, get_engine: Callable) -> None:
                         "proposed": new_state.value,
                     })
             if not dry_run:
+                authorization = authorize_mcp_mutation(
+                    engine,
+                    "update",
+                    mutation_source="mcp-compact-memories",
+                    profile_id=pid,
+                )
                 for c in candidates:
                     engine._db.update_fact(
                         c["fact_id"], {"lifecycle": c["proposed"]},
                     )
+                authorization.complete()
             return {
                 "success": True,
                 "dry_run": dry_run,

package/src/superlocalmemory/mcp/tools_v3.py

@@ -14,6 +14,8 @@ from __future__ import annotations
 import logging
 from typing import Callable
 
+from superlocalmemory.mcp.shared import authorize_mcp_mutation
+
 logger = logging.getLogger(__name__)
 
 
@@ -64,6 +66,14 @@ def register_v3_tools(server, get_engine: Callable) -> None:
                     "success": False,
                     "error": f"Invalid mode '{mode}'. Use 'a', 'b', or 'c'.",
                 }
+            engine = get_engine()
+            authorization = authorize_mcp_mutation(
+                engine,
+                "update",
+                mutation_source="mcp-set-mode",
+                profile_id=engine.profile_id,
+                content_preview=mode_lower,
+            )
             from superlocalmemory.core.config import SLMConfig
             from superlocalmemory.mcp.server import reset_engine
 
@@ -80,6 +90,7 @@ def register_v3_tools(server, get_engine: Callable) -> None:
             )
 
             reset_engine()
+            authorization.complete()
 
             return {
                 "success": True,
@@ -290,8 +301,16 @@ def register_v3_tools(server, get_engine: Callable) -> None:
                 results.append({
                     "fact_id": item.get("fact_id", ""),
                     "content": item.get("content", ""),
-                    "final_score": round(float(item.get("score", 0.0)), 4),
+                    "score": round(float(item.get("score", 0.0)), 4),
+                    "relevance_score": round(
+                        float(item.get("relevance_score", item.get("score", 0.0))), 4
+                    ),
+                    "ranking_score": item.get("ranking_score"),
                     "confidence": round(float(item.get("confidence", 0.0)), 3),
+                    "memory_confidence": round(
+                        float(item.get("memory_confidence", item.get("confidence", 0.0))), 3
+                    ),
+                    "rank_position": int(item.get("rank_position", 0)),
                     "trust_score": round(float(item.get("trust_score", 0.0)), 3),
                     "channel_scores": item.get("channel_scores", {}) or {},
                     "evidence_chain": item.get("evidence_chain", []) or [],
@@ -307,6 +326,12 @@ def register_v3_tools(server, get_engine: Callable) -> None:
                 "channel_weights": raw.get("channel_weights", {}) if isinstance(raw, dict) else {},
                 "total_candidates": raw.get("total_candidates", 0) if isinstance(raw, dict) else 0,
                 "retrieval_time_ms": round(float(raw.get("retrieval_time_ms", 0.0)) if isinstance(raw, dict) else 0.0, 1),
+                "score_contract_version": raw.get("score_contract_version", "2") if isinstance(raw, dict) else "2",
+                "calibration_status": raw.get("calibration_status", "uncalibrated") if isinstance(raw, dict) else "uncalibrated",
+                "calibration_id": raw.get("calibration_id") if isinstance(raw, dict) else None,
+                "answer_confidence": raw.get("answer_confidence") if isinstance(raw, dict) else None,
+                "abstained": bool(raw.get("abstained", False)) if isinstance(raw, dict) else False,
+                "abstention_reason": raw.get("abstention_reason") if isinstance(raw, dict) else None,
             }
         except Exception as exc:
             logger.exception("recall_trace failed")