superlocalmemory 3.8.10 → 3.8.12

package/src/superlocalmemory/mcp/tools_active.py

@@ -140,6 +140,117 @@ def _emit_event(event_type: str, payload: dict | None = None,
         logger.warning("event emit failed: type=%s err=%s", event_type, exc)
 
 
+# ---------------------------------------------------------------------------
+# Canonical learning-store feedback (issues #102, #106)
+#
+# learning.db is the single store every learning consumer reads. Within it the
+# canonical tables are ``learning_signals`` + ``learning_features``: the phase
+# gate (recall_pipeline), the dashboard Living Brain panel, the ranker-phase
+# card, and the retrainer all resolve their phase from ``learning_signals``.
+# ``learning_feedback`` is the pre-v3.4.22 table that legacy_migration copies
+# forward into it.
+#
+# Recall itself is deliberately read-only and must never open a writer, so an
+# explicit feedback command is the only durable writer in the design. These
+# helpers are that writer, and — per issue #106 — they report the SAME number
+# the gate and the dashboard use. There is deliberately no fall back to a
+# different store's count: a cross-store fallback is what let a total write
+# failure still return "success" beside a plausibly incrementing counter.
+# ---------------------------------------------------------------------------
+
+_FEEDBACK_SIGNAL_MAP: dict[str, tuple[str, float]] = {
+    "relevant": ("user_positive", 1.0),
+    "irrelevant": ("user_negative", 0.0),
+    "partial": ("user_correction", 0.5),
+}
+
+
+def _learning_db_path():
+    """Resolve the canonical learning.db path."""
+    return state_path("learning.db")
+
+
+def _phase_thresholds() -> tuple[int, int]:
+    """Return the (phase 2, phase 3) signal thresholds.
+
+    Sourced from ``learning.ranker`` so the MCP surface can never report a
+    different phase than the one recall actually applies. Falls back to the
+    documented defaults only if the learning package is unavailable.
+    """
+    try:
+        from superlocalmemory.learning.ranker import (
+            PHASE_2_THRESHOLD,
+            PHASE_3_THRESHOLD,
+        )
+        return PHASE_2_THRESHOLD, PHASE_3_THRESHOLD
+    except Exception:  # pragma: no cover — learning extras absent
+        return 50, 200
+
+
+_PHASE_2_THRESHOLD, _PHASE_3_THRESHOLD = _phase_thresholds()
+
+
+def _phase_for_signal_count(count: int) -> int:
+    """Map a canonical signal count onto the adaptive ranking phase."""
+    if count < _PHASE_2_THRESHOLD:
+        return 1
+    return 2 if count < _PHASE_3_THRESHOLD else 3
+
+
+def _record_canonical_feedback(
+    *, profile_id: str, fact_id: str, feedback: str, query: str = "",
+    channel: str = "explicit",
+) -> bool:
+    """Write explicit feedback to learning.db. Returns True on success.
+
+    True means the ``learning_signals`` row that every phase counter reads
+    actually landed — not merely that some row was written somewhere. The
+    outcome is RETURNED rather than swallowed so the caller can tell the user
+    the truth about whether the write was durable.
+    """
+    signal_type, value = _FEEDBACK_SIGNAL_MAP.get(
+        feedback, ("user_correction", 0.5),
+    )
+    try:
+        from superlocalmemory.learning.feedback import FeedbackCollector
+
+        collector = FeedbackCollector(_learning_db_path())
+        write = collector.record_explicit_event(
+            profile_id=profile_id,
+            fact_id=fact_id,
+            signal_type=signal_type,
+            value=value,
+            query=query,
+            channel=channel,
+        )
+        return write.canonical
+    except Exception as exc:
+        logger.warning(
+            "canonical feedback write failed (fact_id=%s): %s", fact_id, exc,
+        )
+        return False
+
+
+def _canonical_feedback_count(profile_id: str) -> int | None:
+    """Count the store that gates the adaptive phases.
+
+    Returns None when the store cannot be read. The caller must NOT substitute
+    a count from a different table: before issue #106 an unreadable learning.db
+    silently fell back to ``feedback_records`` in memory.db — a table no
+    consumer reads — so the user watched a fabricated counter climb toward a
+    threshold that nothing was measuring, while the durable write did nothing.
+    """
+    try:
+        from superlocalmemory.learning.feedback import FeedbackCollector
+
+        return FeedbackCollector(
+            _learning_db_path(),
+        ).get_signal_count(profile_id)
+    except Exception as exc:
+        logger.warning("canonical feedback count failed: %s", exc)
+        return None
+
+
 def register_active_tools(server, get_engine: Callable) -> None:
     """Register 3 active memory tools on *server*."""
 
@@ -369,16 +480,19 @@ def register_active_tools(server, get_engine: Callable) -> None:
                     "source_type": m.source_type,
                 })
 
-            # Get learning status
-            feedback_count = 0
-            try:
-                feedback_count = engine._adaptive_learner.get_feedback_count(pid)
-            except Exception as exc:
-                # Feedback count is a Dash-Core signal; a silent zero
-                # masks wiring bugs. Log so operators see the failure.
+            # Learning status — issue #106: read the SAME canonical counter
+            # that report_feedback reports, the recall gate applies, and the
+            # dashboard displays. This used to read ``feedback_records`` in
+            # memory.db, so session_init and report_feedback returned two
+            # different "signal" totals for one profile in the same session.
+            # A silent zero masks wiring bugs, so a failed read is logged.
+            feedback_count = _canonical_feedback_count(pid)
+            if feedback_count is None:
                 logger.warning(
-                    "session_init feedback_count read failed: %s", exc,
+                    "session_init canonical signal count unavailable for "
+                    "profile %s; reporting 0", pid,
                 )
+                feedback_count = 0
 
             # v3.6.9 (#35): generate a stable session_id so clients can pass it
             # to remember() and close_session() for proper session aggregation.
@@ -412,11 +526,13 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 "abstention_reason": getattr(response, "abstention_reason", None),
                 "learning": {
                     "feedback_signals": feedback_count,
-                    "phase": 1 if feedback_count < 50 else (2 if feedback_count < 200 else 3),
+                    "phase": _phase_for_signal_count(feedback_count),
                     "status": (
                         "collecting"
-                        if feedback_count < 50
-                        else "learning" if feedback_count < 200 else "trained"
+                        if feedback_count < _PHASE_2_THRESHOLD
+                        else "learning"
+                        if feedback_count < _PHASE_3_THRESHOLD
+                        else "trained"
                     ),
                 },
             }
@@ -551,25 +667,71 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 profile_id=pid,
             )
 
-            count = engine._adaptive_learner.get_feedback_count(pid)
+            # The AdaptiveLearner write above lands in ``feedback_records`` in
+            # memory.db — a table whose only readers are AdaptiveLearner's own
+            # count and its train(), which nothing in the running system
+            # calls. It is kept so existing data and GDPR erasure stay intact,
+            # but it is NOT the learning write and its count is NOT reported.
+            #
+            # The canonical store is learning.db's ``learning_signals`` (+ the
+            # paired ``learning_features`` row). Writing there is what makes
+            # feedback do work: the recall phase gate, the dashboard Living
+            # Brain panel, the ranker-phase card, and the retrainer all read
+            # it. Recall stays read-only by design, so this explicit path is
+            # the only durable writer.
+            canonical_recorded = _record_canonical_feedback(
+                profile_id=pid,
+                fact_id=fact_id,
+                feedback=feedback,
+                query=query,
+            )
+
+            # issue #106: report the count from the store that ACTUALLY gates
+            # the phases, and report NOTHING when it cannot be read. The old
+            # fallback to ``feedback_records`` is what made a total write
+            # failure indistinguishable from success: the response carried a
+            # plausible, incrementing ``total_signals`` sourced from a table
+            # nothing consumes, so the caller had no way to notice that
+            # learning.db was never touched.
+            count = _canonical_feedback_count(pid)
             authorization.complete()
 
+            if not canonical_recorded or count is None:
+                # Never claim a durable learning write that did not happen.
+                return {
+                    "success": False,
+                    "durable": False,
+                    "feedback_id": record.feedback_id,
+                    "total_signals": count,
+                    "error": (
+                        "Feedback was accepted but could not be written to "
+                        "the canonical learning store (learning.db), so it "
+                        "will not influence ranking. Run 'slm doctor' to "
+                        "diagnose learning.db."
+                    ),
+                }
+
+            phase = _phase_for_signal_count(count)
             _emit_event("pattern.learned", {
                 "fact_id": fact_id,
                 "feedback": feedback,
                 "total_signals": count,
-                "phase": 1 if count < 50 else (2 if count < 200 else 3),
+                "phase": phase,
             })
 
-            return {
+            result = {
                 "success": True,
+                "durable": True,
                 "feedback_id": record.feedback_id,
                 "total_signals": count,
-                "phase": 1 if count < 50 else (2 if count < 200 else 3),
+                "phase": phase,
                 "message": f"Feedback recorded. {count} total signals."
-                + (" Phase 2 unlocked!" if count == 50 else "")
-                + (" Phase 3 (ML) unlocked!" if count == 200 else ""),
+                + (" Phase 2 unlocked!"
+                   if count == _PHASE_2_THRESHOLD else "")
+                + (" Phase 3 (ML) unlocked!"
+                   if count == _PHASE_3_THRESHOLD else ""),
             }
+            return result
         except Exception as exc:
             logger.exception("report_feedback failed")
             return {"success": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_core.py

@@ -21,6 +21,7 @@ from mcp.types import ToolAnnotations
 
 from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
 from superlocalmemory.infra.data_root import state_path
+from superlocalmemory.mcp._daemon_proxy import daemon_unavailable_error
 from superlocalmemory.mcp.shared import authorize_mcp_mutation
 
 logger = logging.getLogger(__name__)
@@ -155,7 +156,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     "code": "DAEMON_UNAVAILABLE",
                     "retryable": True,
                     "error": (
-                        "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later."
+                        daemon_unavailable_error()
                     ),
                 }
         except Exception as dexc:
@@ -166,7 +167,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     "code": "DAEMON_UNAVAILABLE",
                     "retryable": True,
                     "error": (
-                        "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later."
+                        daemon_unavailable_error()
                     ),
                 }
 
@@ -198,14 +199,14 @@ def register_core_tools(server, get_engine: Callable) -> None:
                         "retryable": True,
                         "error": stored.get(
                             "error",
-                            "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+                            daemon_unavailable_error(),
                         ),
                     }
                 return {
                     "success": False,
                     "code": "DAEMON_UNAVAILABLE",
                     "retryable": True,
-                    "error": "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+                    "error": daemon_unavailable_error(),
                 }
             fact_ids = list(stored.get("fact_ids") or [])
             materialization_state = str(
@@ -242,7 +243,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 "success": False,
                 "code": "DAEMON_UNAVAILABLE",
                 "retryable": True,
-                "error": "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later.",
+                "error": daemon_unavailable_error(),
             }
 
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))