superlocalmemory 3.8.10 → 3.8.12

package/src/superlocalmemory/retrieval/reranker.py

@@ -84,6 +84,21 @@ _WARMUP_MAX_ATTEMPTS = int(os.environ.get("SLM_RERANKER_WARMUP_ATTEMPTS", "5"))
 _WARMUP_RETRY_BACKOFF_S = float(os.environ.get("SLM_RERANKER_WARMUP_BACKOFF", "3"))
 
 
+# Substrings that mark a load failure as a configuration problem rather than a
+# transient one. Retrying these can never succeed, so the warmup aborts on the
+# first occurrence instead of spending _WARMUP_MAX_ATTEMPTS × backoff on them.
+_PERMANENT_LOAD_ERROR_MARKERS = (
+    "unknown backend",
+    "sentence-transformers is not installed",
+)
+
+
+def _is_permanent_load_error(error: str) -> bool:
+    """True when a worker load error cannot be fixed by retrying."""
+    lowered = (error or "").lower()
+    return any(m in lowered for m in _PERMANENT_LOAD_ERROR_MARKERS)
+
+
 class CrossEncoderReranker:
     """Rerank candidate facts using a local cross-encoder model.
 
@@ -201,11 +216,43 @@ class CrossEncoderReranker:
                                 resp.get("warmup_inference", False),
                             )
                             return
-                        logger.warning(
-                            "Reranker warmup attempt %d/%d did not confirm "
-                            "ready (timeout=%ds); retrying",
-                            attempt, _WARMUP_MAX_ATTEMPTS, _WARMUP_LOAD_TIMEOUT,
-                        )
+                        # v3.8.11 (issue #103): this used to report
+                        # "(timeout=90s)" for EVERY failure, including loads
+                        # that failed instantly. A user whose retries were 3s
+                        # apart was told each one timed out after 90s, and the
+                        # worker's actual error was never printed at all.
+                        # Distinguish the two cases and surface the real cause.
+                        if resp is None:
+                            logger.warning(
+                                "Reranker warmup attempt %d/%d: no response "
+                                "from worker within %ds; retrying",
+                                attempt, _WARMUP_MAX_ATTEMPTS,
+                                _WARMUP_LOAD_TIMEOUT,
+                            )
+                        else:
+                            load_error = (
+                                resp.get("error")
+                                or "worker reported not-ready without an error"
+                            )
+                            # A misconfiguration cannot fix itself. Retrying a
+                            # bad backend name or a missing dependency four
+                            # more times burns ~7.5 minutes of daemon startup
+                            # to reach the same answer (issue #103). Fail fast
+                            # and say exactly what to change.
+                            if _is_permanent_load_error(load_error):
+                                logger.error(
+                                    "Reranker disabled — configuration error: "
+                                    "%s. Not retrying. Fix the config or set "
+                                    "retrieval.use_cross_encoder=false; recall "
+                                    "continues with fusion scores.",
+                                    load_error,
+                                )
+                                return
+                            logger.warning(
+                                "Reranker warmup attempt %d/%d failed: %s; "
+                                "retrying",
+                                attempt, _WARMUP_MAX_ATTEMPTS, load_error,
+                            )
 
                     if attempt < _WARMUP_MAX_ATTEMPTS and not self._model_loaded:
                         if self._shutdown_event.wait(

package/src/superlocalmemory/server/unified_daemon.py

@@ -534,6 +534,10 @@ def _recall_keyword_fallback(engine, query: str, limit: int) -> dict:
         "results": results,
         "count": len(results),
         "no_confident_match": True,
+        # PR #101: every other recall path returns this key, so clients format
+        # it unconditionally. Omitting it here made the degraded path — the one
+        # that fires when recall is ALREADY struggling — crash the CLI.
+        "retrieval_time_ms": 0,
     }
 
 # v3.4.52: Embedding model warm state. Set to True by the async pre-warm

package/src/superlocalmemory/storage/migration_runner.py

@@ -128,6 +128,9 @@ from superlocalmemory.storage.migrations import (
 from superlocalmemory.storage.migrations import (
     M032_write_coordinator_admission as _M032,
 )
+from superlocalmemory.storage.migrations import (
+    M033_learning_feedback_channel as _M033,
+)
 
 # Map migration name → module (used for the optional ``verify(conn)`` hook
 # that lets the runner detect "already applied" state when an idempotent
@@ -164,6 +167,7 @@ _MODULES = {
     _M030.NAME: _M030,
     _M031.NAME: _M031,
     _M032.NAME: _M032,
+    _M033.NAME: _M033,
 }
 
 logger = logging.getLogger(__name__)
@@ -220,6 +224,11 @@ MIGRATIONS: list[Migration] = [
     # observations for ShadowTest persistence across daemon restart.
     Migration(name=_M012.NAME, db_target="learning", ddl=_M012.DDL,
               dependencies=(_M003.NAME,)),
+    # M033 adds learning_feedback.channel, which pattern_miner has always
+    # queried but which no schema ever defined. Its DDL creates the table
+    # when absent, so it needs no dependency beyond the migration log.
+    Migration(name=_M033.NAME, db_target="learning", ddl=_M033.DDL,
+              dependencies=(_M003.NAME,)),
     Migration(name=_M004.NAME, db_target="memory", ddl=_M004.DDL),
     # M007 creates pending_outcomes (memory.db, LLD-00 §1.2).
     Migration(name=_M007.NAME, db_target="memory", ddl=_M007.DDL),

package/src/superlocalmemory/storage/migrations/M033_learning_feedback_channel.py

@@ -0,0 +1,77 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory v3.8.11
+
+"""M033 — add the ``channel`` column to ``learning_feedback``.
+
+``pattern_miner._mine_channel_and_coretrieval`` has always executed::
+
+    SELECT channel, COUNT(*) AS cnt, AVG(signal_value) AS avg_signal
+    FROM learning_feedback GROUP BY channel
+
+but ``channel`` was never defined on the table. Every database therefore
+raised ``sqlite3.OperationalError: no such column: channel``. That error was
+caught by the miner's outer ``except Exception`` and logged at DEBUG, so the
+failure was invisible — and because the channel query runs FIRST inside that
+try block, it also aborted the co-retrieval mining below it. One missing
+column silently disabled two pattern types (issue #102, "Patterns learned
+remains 0" despite a restored backup: restoring rows cannot fix a schema gap).
+
+Additive only — ``ALTER TABLE ADD COLUMN`` with a default. No data loss and no
+type changes; existing rows get ``'unknown'``, which groups cleanly rather than
+being dropped by the miner's ``GROUP BY``.
+
+``learning_feedback`` is bootstrapped at runtime by
+``learning.feedback.FeedbackCollector._ensure_schema`` rather than by a
+migration, so the DDL below CREATEs it (without ``channel``) when absent
+before the ALTER. That keeps all three states correct:
+
+  - table missing            -> CREATE, then ALTER adds ``channel``
+  - table present, no column -> CREATE is a no-op, ALTER adds ``channel``
+  - table already migrated   -> ``verify()`` returns True, runner skips entirely
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M033_learning_feedback_channel"
+DB_TARGET = "learning"
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Return True if ``learning_feedback.channel`` already exists."""
+    try:
+        cols = {
+            row[1] for row in
+            conn.execute("PRAGMA table_info(learning_feedback)").fetchall()
+        }
+    except sqlite3.Error:
+        return False
+    # An empty set means the table does not exist yet — not migrated.
+    return bool(cols) and "channel" in cols
+
+
+DDL = """
+BEGIN IMMEDIATE;
+
+CREATE TABLE IF NOT EXISTS learning_feedback (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id   TEXT    NOT NULL,
+    fact_id      TEXT    NOT NULL,
+    signal_type  TEXT    NOT NULL,
+    signal_value REAL    NOT NULL,
+    query_hash   TEXT,
+    created_at   TEXT    NOT NULL,
+    metadata     TEXT
+);
+
+ALTER TABLE learning_feedback ADD COLUMN channel TEXT DEFAULT 'unknown';
+
+CREATE INDEX IF NOT EXISTS idx_feedback_profile
+    ON learning_feedback (profile_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_feedback_channel
+    ON learning_feedback (profile_id, channel);
+
+COMMIT;
+"""

package/src/superlocalmemory/storage/migrations/__init__.py

@@ -28,6 +28,7 @@ from . import (
     M020_model_state_integrity,
     M029_behavioral_history_indexes,
     M030_entity_explorer_indexes,
+    M033_learning_feedback_channel,
 )
 
 # ---------------------------------------------------------------------------
@@ -81,6 +82,7 @@ __all__ = (
     "M020_model_state_integrity",
     "M029_behavioral_history_indexes",
     "M030_entity_explorer_indexes",
+    "M033_learning_feedback_channel",
     # Legacy re-exports (backward compat):
     "CURRENT_SCHEMA_VERSION",
     "get_schema_version",