superlocalmemory 3.8.9 → 3.8.11

package/src/superlocalmemory/core/reranker_worker.py

@@ -119,7 +119,9 @@ def _worker_main() -> None:
         if cmd == "load":
             name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-12-v2")
             backend = req.get("backend", "onnx")
-            model, active_backend, model_name = _load_model(name, backend)
+            model, active_backend, model_name, load_error = _load_model(
+                name, backend,
+            )
             # V3.3.16: Run real inference to trigger ONNX CoreML JIT compilation.
             # Without this, first real rerank call triggers 30-60s compilation
             # that exceeds the caller's timeout, killing the worker.
@@ -147,6 +149,9 @@ def _worker_main() -> None:
                 "backend": active_backend,
                 "model": model_name,
                 "warmup_inference": warmup_ok,
+                # Carries the real reason to the parent so the warmup log can
+                # print it instead of a generic timeout message (issue #103).
+                "error": load_error,
             })
             continue
 
@@ -160,9 +165,14 @@ def _worker_main() -> None:
                 # Auto-load with defaults
                 name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-12-v2")
                 backend = req.get("backend", "onnx")
-                model, active_backend, model_name = _load_model(name, backend)
+                model, active_backend, model_name, load_error = _load_model(
+                    name, backend,
+                )
             if model is None:
-                _respond({"ok": False, "error": "Model load failed"})
+                _respond({
+                    "ok": False,
+                    "error": load_error or "Model load failed",
+                })
                 continue
             try:
                 pairs = [(query, doc) for doc in documents]
@@ -195,9 +205,14 @@ def _worker_main() -> None:
             if model is None:
                 name = req.get("model_name", "cross-encoder/ms-marco-MiniLM-L-12-v2")
                 backend = req.get("backend", "onnx")
-                model, active_backend, model_name = _load_model(name, backend)
+                model, active_backend, model_name, load_error = _load_model(
+                    name, backend,
+                )
             if model is None:
-                _respond({"ok": False, "error": "Model load failed"})
+                _respond({
+                    "ok": False,
+                    "error": load_error or "Model load failed",
+                })
                 continue
             try:
                 try:
@@ -214,10 +229,13 @@ def _worker_main() -> None:
         _respond({"ok": False, "error": f"Unknown command: {cmd}"})
 
 
+_KNOWN_BACKENDS = ("onnx", "", "pytorch", "torch")
+
+
 def _load_model(
     name: str, backend: str,
 ) -> tuple:
-    """Load cross-encoder model. Returns (model, backend_name, model_name).
+    """Load cross-encoder model. Returns (model, backend_name, model_name, error).
 
     V3.3.13: sentence-transformers 5.x+ supports backend='onnx' for
     CrossEncoder. We use a 3-tier fallback chain:
@@ -231,6 +249,19 @@ def _load_model(
       x86_64    → model_quint8_avx2.onnx
       Fallback  → model.onnx (generic)
     """
+    # v3.8.11 (issue #103): an unrecognised backend used to fall through to
+    # the PyTorch tier and fail there with a confusing model-load error. A
+    # user who set backend="openai" expecting a remote reranker got five
+    # silent failures and no hint that the value meant nothing. Name it.
+    if backend not in _KNOWN_BACKENDS:
+        return None, "", "", (
+            f"unknown backend {backend!r}; supported values are "
+            f"'onnx' or '' (PyTorch). SuperLocalMemory has no remote/"
+            f"OpenAI-compatible reranker backend — the cross-encoder always "
+            f"runs locally, so 'cross_encoder_endpoint' has no effect."
+        )
+
+    tier_errors: list[str] = []
     try:
         from sentence_transformers import CrossEncoder
 
@@ -242,24 +273,35 @@ def _load_model(
                     name, backend="onnx",
                     model_kwargs={"file_name": onnx_file},
                 )
-                return m, f"onnx-quantized({onnx_file})", name
-            except Exception:
-                pass
+                return m, f"onnx-quantized({onnx_file})", name, ""
+            except Exception as exc:
+                tier_errors.append(f"onnx-quantized: {exc}")
 
             # Tier 2: Generic ONNX (auto-exported by optimum)
             try:
                 m = CrossEncoder(name, backend="onnx")
-                return m, "onnx", name
-            except Exception:
-                pass
+                return m, "onnx", name, ""
+            except Exception as exc:
+                tier_errors.append(f"onnx: {exc}")
 
         # Tier 3: PyTorch (always works, no ONNX dependency needed)
         m = CrossEncoder(name)
-        return m, "pytorch", name
-    except ImportError:
-        return None, "", ""
-    except Exception:
-        return None, "", ""
+        return m, "pytorch", name, ""
+    except ImportError as exc:
+        # Previously indistinguishable from a bad model name.
+        return None, "", "", (
+            f"sentence-transformers is not installed ({exc}); "
+            f"install it or set retrieval.use_cross_encoder=false"
+        )
+    except Exception as exc:
+        tier_errors.append(f"pytorch: {exc}")
+        # Every tier's real error, propagated instead of discarded. Before
+        # 3.8.11 this returned (None, "", "") and the operator saw only a
+        # generic "did not confirm ready" line from the parent process.
+        return None, "", "", (
+            f"could not load cross-encoder model {name!r} "
+            f"(backend={backend or 'pytorch'}): " + "; ".join(tier_errors)
+        )
 
 
 def _respond(data: dict) -> None:

package/src/superlocalmemory/hooks/adapter_base.py

@@ -26,7 +26,6 @@ from __future__ import annotations
 import hashlib
 import os
 import sqlite3
-import sys
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
@@ -76,8 +75,11 @@ class Adapter(Protocol):
 
 def path_sha256(path: Path) -> str:
     """SHA-256 of the absolute path string, full 64-hex (never truncated)."""
-    return hashlib.sha256(str(path.resolve() if path.exists()
-                              else path).encode("utf-8")).hexdigest()
+    # The identity must not depend on whether the target exists. On Windows,
+    # Path.resolve() can normalize an existing path differently from the same
+    # not-yet-created path, changing the sync-log key after the first write.
+    canonical = os.path.normcase(os.path.abspath(os.fspath(path)))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()
 
 
 def _now_iso() -> str:
@@ -252,6 +254,11 @@ def atomic_write(
     flags = os.O_WRONLY | os.O_CREAT | os.O_TRUNC
     if hasattr(os, "O_NOFOLLOW") and _is_posix():
         flags |= os.O_NOFOLLOW  # SEC — POSIX refuses symlinks
+    if hasattr(os, "O_BINARY") and not _is_posix():
+        # Windows file descriptors default to text mode, which rewrites LF
+        # bytes as CRLF.  The sync log hashes the caller's original bytes, so
+        # text-mode conversion makes an unchanged file look modified forever.
+        flags |= os.O_BINARY
 
     mode = posix_mode if _is_posix() else windows_mode
     fd = os.open(str(tmp), flags, mode)

package/src/superlocalmemory/learning/feedback.py

@@ -53,6 +53,13 @@ _DASHBOARD_SIGNAL_MAP: Dict[str, tuple[str, float]] = {
     "dwell_negative": ("dwell_negative", 0.2),
 }
 
+# ``channel`` records WHICH retrieval channel surfaced the fact (semantic,
+# bm25, entity_graph, temporal, ...). ``pattern_miner._mine_channel_and_
+# coretrieval`` groups on it to mine ``channel_performance`` patterns. It was
+# read by the miner but never defined here, so every fresh database raised
+# "no such column: channel" — swallowed at debug level, which silently killed
+# BOTH channel mining and the co-retrieval mining that followed it in the same
+# try block. Defined here for new databases; M033 back-fills existing ones.
 _CREATE_TABLE = """
 CREATE TABLE IF NOT EXISTS learning_feedback (
     id           INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -62,7 +69,8 @@ CREATE TABLE IF NOT EXISTS learning_feedback (
     signal_value REAL    NOT NULL,
     query_hash   TEXT,
     created_at   TEXT    NOT NULL,
-    metadata     TEXT
+    metadata     TEXT,
+    channel      TEXT    DEFAULT 'unknown'
 )
 """
 
@@ -71,6 +79,11 @@ CREATE INDEX IF NOT EXISTS idx_feedback_profile
     ON learning_feedback (profile_id, created_at DESC)
 """
 
+_CREATE_CHANNEL_INDEX = """
+CREATE INDEX IF NOT EXISTS idx_feedback_channel
+    ON learning_feedback (profile_id, channel)
+"""
+
 
 def _utcnow_iso() -> str:
     """Return current UTC time as ISO-8601 string."""
@@ -108,6 +121,20 @@ class FeedbackCollector:
         try:
             conn.execute(_CREATE_TABLE)
             conn.execute(_CREATE_INDEX)
+            # Pre-3.8.11 databases created ``learning_feedback`` without the
+            # ``channel`` column. M033 covers migrated installs; this ADD keeps
+            # a collector pointed at a legacy file self-healing rather than
+            # failing every channel query for the life of the process.
+            existing = {
+                row[1] for row in
+                conn.execute("PRAGMA table_info(learning_feedback)")
+            }
+            if "channel" not in existing:
+                conn.execute(
+                    "ALTER TABLE learning_feedback "
+                    "ADD COLUMN channel TEXT DEFAULT 'unknown'"
+                )
+            conn.execute(_CREATE_CHANNEL_INDEX)
             conn.commit()
         finally:
             conn.close()
@@ -196,16 +223,29 @@ class FeedbackCollector:
         fact_id: str,
         signal_type: str,
         value: float,
+        query: str = "",
+        channel: str = "unknown",
     ) -> Optional[int]:
         """
         Record explicit user feedback on a specific fact.
 
+        This is the canonical durable write for the learning system. Recall
+        itself is deliberately read-only (it must never open a writer — see
+        ``test_readonly_bandit_uses_uri_read_connection_and_never_records_play``),
+        so explicit feedback is the ONLY path that grows ``learning_feedback``.
+        Every downstream consumer reads this table: the phase gate
+        (``_ReadOnlyLearningView.count_feedback`` unlocks adaptive ranking at
+        50 rows), ``pattern_miner`` (channel_performance), and the dashboard.
+
         Args:
             profile_id:  Profile providing feedback.
             fact_id:     The fact being rated.
             signal_type: One of ``user_positive``, ``user_negative``,
                          ``user_correction``, or any custom type.
             value:       Numeric signal value (0.0 to 1.0).
+            query:       Originating query. Stored only as a SHA-256[:16]
+                         hash — full text is never persisted.
+            channel:     Retrieval channel that surfaced the fact.
 
         Returns:
             Row ID of the inserted record, or None on error.
@@ -215,6 +255,7 @@ class FeedbackCollector:
 
         clamped = max(0.0, min(1.0, float(value)))
         now = _utcnow_iso()
+        query_hash = _hash_query(query) if query else None
 
         with self._lock:
             conn = self._connect()
@@ -222,9 +263,10 @@ class FeedbackCollector:
                 cursor = conn.execute(
                     "INSERT INTO learning_feedback "
                     "(profile_id, fact_id, signal_type, signal_value, "
-                    "query_hash, created_at, metadata) "
-                    "VALUES (?, ?, ?, ?, ?, ?, ?)",
-                    (profile_id, fact_id, signal_type, clamped, None, now, None),
+                    "query_hash, created_at, metadata, channel) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+                    (profile_id, fact_id, signal_type, clamped, query_hash,
+                     now, None, channel or "unknown"),
                 )
                 conn.commit()
                 return cursor.lastrowid

package/src/superlocalmemory/learning/pattern_miner.py

@@ -325,14 +325,28 @@ def _mine_channel_and_coretrieval(
         learn_conn = sqlite3.connect(learning_db, timeout=10)
         learn_conn.row_factory = sqlite3.Row
 
-        channel_rows = learn_conn.execute(
-            "SELECT channel, COUNT(*) AS cnt, "
-            "AVG(signal_value) AS avg_signal "
-            "FROM learning_feedback "
-            "WHERE profile_id = ? "
-            "GROUP BY channel ORDER BY cnt DESC",
-            (profile_id,),
-        ).fetchall()
+        # Isolated from the co-retrieval block below. Until 3.8.11
+        # ``learning_feedback`` had no ``channel`` column, so this query
+        # raised and — sharing one try with co-retrieval — took that mining
+        # down with it. Two pattern types died from one missing column, and
+        # the only trace was a DEBUG line. Each miner now fails alone, loudly.
+        channel_rows = []
+        try:
+            channel_rows = learn_conn.execute(
+                "SELECT channel, COUNT(*) AS cnt, "
+                "AVG(signal_value) AS avg_signal "
+                "FROM learning_feedback "
+                "WHERE profile_id = ? "
+                "GROUP BY channel ORDER BY cnt DESC",
+                (profile_id,),
+            ).fetchall()
+        except sqlite3.Error as exc:
+            logger.warning(
+                "Channel pattern mining skipped — learning_feedback query "
+                "failed (%s). Run 'slm db migrate' to apply M033 if this "
+                "reports a missing 'channel' column. Co-retrieval mining "
+                "continues.", exc,
+            )
 
         for row in channel_rows:
             d = dict(row)
@@ -376,12 +390,18 @@ def _mine_channel_and_coretrieval(
                     confidence=min(1.0, len(coret_rows) / 10),
                 )
                 gen += 1
-        except Exception:
-            pass
+        except sqlite3.Error as exc:
+            logger.warning(
+                "Co-retrieval pattern mining skipped — co_retrieval_edges "
+                "query failed: %s", exc,
+            )
 
         learn_conn.close()
     except Exception as exc:
-        logger.debug("Signal pattern mining failed: %s", exc)
+        # Was DEBUG. A learning subsystem that mines nothing must say so at a
+        # level operators actually see; issue #102 went undiagnosed for weeks
+        # because the only evidence was invisible by default.
+        logger.warning("Signal pattern mining failed: %s", exc)
     return gen
 
 

package/src/superlocalmemory/mcp/tools_active.py

@@ -140,6 +140,78 @@ 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 (issue #102)
+#
+# learning.db is the single store every learning consumer reads: the phase
+# gate (recall_pipeline._ReadOnlyLearningView.count_feedback), pattern_miner,
+# the ranker retrainers, and the dashboard. 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.
+# ---------------------------------------------------------------------------
+
+_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 _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.
+
+    Best-effort by design — a learning write must never fail the user's
+    feedback call — but 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())
+        row_id = collector.record_explicit(
+            profile_id=profile_id,
+            fact_id=fact_id,
+            signal_type=signal_type,
+            value=value,
+            query=query,
+            channel=channel,
+        )
+        return row_id is not None
+    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 rows in the store that gates the adaptive phases.
+
+    Returns None when the store cannot be read, so the caller can fall back
+    rather than report a misleading zero.
+    """
+    try:
+        from superlocalmemory.learning.feedback import FeedbackCollector
+
+        return FeedbackCollector(
+            _learning_db_path(),
+        ).get_feedback_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*."""
 
@@ -551,25 +623,64 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 profile_id=pid,
             )
 
-            count = engine._adaptive_learner.get_feedback_count(pid)
+            # v3.8.11 (issue #102): 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. Reported feedback therefore
+            # returned success and an incrementing counter while every actual
+            # consumer saw nothing.
+            #
+            # The canonical learning store is learning.db. Writing here is
+            # what makes feedback do work: the phase gate
+            # (_ReadOnlyLearningView.count_feedback) unlocks adaptive ranking
+            # at 50 rows, pattern_miner mines channel_performance from it, and
+            # the dashboard Living Brain reads it. Recall stays read-only by
+            # design, so this explicit path is the ONLY durable writer.
+            #
+            # Kept alongside (not replacing) the AdaptiveLearner write so
+            # existing feedback_records data and GDPR erasure stay intact.
+            canonical_recorded = _record_canonical_feedback(
+                profile_id=pid,
+                fact_id=fact_id,
+                feedback=feedback,
+                query=query,
+            )
+
+            # Report the count from the store that ACTUALLY gates the phases.
+            # Pre-3.8.11 this returned the feedback_records count, so the
+            # caller watched a number climb toward 50 while the gate — which
+            # reads learning_feedback — never moved.
+            count = _canonical_feedback_count(pid)
+            if count is None:
+                count = engine._adaptive_learner.get_feedback_count(pid)
             authorization.complete()
 
+            phase = 1 if count < 50 else (2 if count < 200 else 3)
             _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,
                 "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 ""),
             }
+            if not canonical_recorded:
+                # Never claim a durable learning write that did not happen.
+                result["durable"] = False
+                result["warning"] = (
+                    "Feedback was accepted but could not be written to the "
+                    "canonical learning store; it will not influence ranking. "
+                    "Run 'slm doctor' to diagnose learning.db."
+                )
+            return result
         except Exception as exc:
             logger.exception("report_feedback failed")
             return {"success": False, "error": str(exc)}

package/src/superlocalmemory/mcp/tools_core.py

@@ -105,6 +105,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
         # recall window so a parallel/next agent finds memories saved seconds ago.
         # Falls back to the capability-owned worker only if the daemon is
         # unreachable. Raw pending.db writes are legacy replay input only.
+        daemon_owned = False
         try:
             import asyncio as _asyncio
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
@@ -159,6 +160,15 @@ def register_core_tools(server, get_engine: Callable) -> None:
                 }
         except Exception as dexc:
             logger.debug("MCP remember via daemon failed, pending fallback: %s", dexc)
+            if daemon_owned:
+                return {
+                    "success": False,
+                    "code": "DAEMON_UNAVAILABLE",
+                    "retryable": True,
+                    "error": (
+                        "DAEMON_UNAVAILABLE: owned daemon is unavailable; retry later."
+                    ),
+                }
 
         try:
             import asyncio as _asyncio
@@ -174,11 +184,12 @@ def register_core_tools(server, get_engine: Callable) -> None:
                     or "mcp:" + hashlib.sha256(content.encode("utf-8")).hexdigest()
                 ),
             }
-            stored = await _asyncio.to_thread(
-                choose_pool().store,
-                content,
-                worker_meta,
-            )
+
+            def _store_via_daemon_pool():
+                pool = choose_pool()
+                return pool.store(content, worker_meta)
+
+            stored = await _asyncio.to_thread(_store_via_daemon_pool)
             if not isinstance(stored, dict) or not stored.get("ok"):
                 if isinstance(stored, dict) and stored.get("code") == "DAEMON_UNAVAILABLE":
                     return {