superlocalmemory 2.7.3 → 2.7.4

package/src/auto_backup.py

@@ -175,6 +175,22 @@ class AutoBackup:
 
             logger.info(f"Backup created: {backup_name} ({size_mb:.1f} MB)")
 
+            # v2.7.4: Also backup learning.db if it exists
+            learning_db = self.db_path.parent / "learning.db"
+            if learning_db.exists():
+                try:
+                    learning_backup_name = f"learning-{timestamp}{label_suffix}.db"
+                    learning_backup_path = self.backup_dir / learning_backup_name
+                    l_source = sqlite3.connect(learning_db)
+                    l_backup = sqlite3.connect(learning_backup_path)
+                    l_source.backup(l_backup)
+                    l_backup.close()
+                    l_source.close()
+                    l_size = learning_backup_path.stat().st_size / (1024 * 1024)
+                    logger.info(f"Learning backup created: {learning_backup_name} ({l_size:.1f} MB)")
+                except Exception as le:
+                    logger.warning(f"Learning DB backup failed (non-critical): {le}")
+
             # Enforce retention policy
             self._enforce_retention()
 
@@ -191,24 +207,24 @@ class AutoBackup:
         """Remove old backups exceeding max_backups limit."""
         max_backups = self.config.get('max_backups', DEFAULT_MAX_BACKUPS)
 
-        # List all backup files sorted by modification time (oldest first)
-        backups = sorted(
-            self.backup_dir.glob('memory-*.db'),
-            key=lambda f: f.stat().st_mtime
-        )
+        # Enforce for both memory and learning backups (v2.7.4)
+        for pattern in ['memory-*.db', 'learning-*.db']:
+            backups = sorted(
+                self.backup_dir.glob(pattern),
+                key=lambda f: f.stat().st_mtime
+            )
 
-        # Remove oldest if exceeding limit
-        while len(backups) > max_backups:
-            oldest = backups.pop(0)
-            try:
-                oldest.unlink()
-                logger.info(f"Removed old backup: {oldest.name}")
-            except OSError as e:
-                logger.error(f"Failed to remove old backup {oldest.name}: {e}")
+            while len(backups) > max_backups:
+                oldest = backups.pop(0)
+                try:
+                    oldest.unlink()
+                    logger.info(f"Removed old backup: {oldest.name}")
+                except OSError as e:
+                    logger.error(f"Failed to remove old backup {oldest.name}: {e}")
 
     def list_backups(self) -> List[Dict]:
         """
-        List all available backups.
+        List all available backups (memory.db + learning.db).
 
         Returns:
             List of backup info dictionaries
@@ -218,20 +234,26 @@ class AutoBackup:
         if not self.backup_dir.exists():
             return backups
 
-        for backup_file in sorted(
-            self.backup_dir.glob('memory-*.db'),
-            key=lambda f: f.stat().st_mtime,
-            reverse=True
-        ):
-            stat = backup_file.stat()
-            backups.append({
-                'filename': backup_file.name,
-                'path': str(backup_file),
-                'size_mb': round(stat.st_size / (1024 * 1024), 2),
-                'created': datetime.fromtimestamp(stat.st_mtime).isoformat(),
-                'age_hours': round((datetime.now() - datetime.fromtimestamp(stat.st_mtime)).total_seconds() / 3600, 1),
-            })
-
+        # v2.7.4: List both memory and learning backups
+        for pattern in ['memory-*.db', 'learning-*.db']:
+            for backup_file in sorted(
+                self.backup_dir.glob(pattern),
+                key=lambda f: f.stat().st_mtime,
+                reverse=True
+            ):
+                stat = backup_file.stat()
+                db_type = 'learning' if backup_file.name.startswith('learning-') else 'memory'
+                backups.append({
+                    'filename': backup_file.name,
+                    'path': str(backup_file),
+                    'size_mb': round(stat.st_size / (1024 * 1024), 2),
+                    'created': datetime.fromtimestamp(stat.st_mtime).isoformat(),
+                    'age_hours': round((datetime.now() - datetime.fromtimestamp(stat.st_mtime)).total_seconds() / 3600, 1),
+                    'type': db_type,
+                })
+
+        # Sort all by creation time (newest first)
+        backups.sort(key=lambda b: b['created'], reverse=True)
         return backups
 
     def restore_backup(self, filename: str) -> bool:
@@ -254,14 +276,20 @@ class AutoBackup:
             # Create a safety backup of current state first
             self.create_backup(label='pre-restore')
 
+            # Determine target DB based on filename prefix
+            if filename.startswith('learning-'):
+                target_db = self.db_path.parent / "learning.db"
+            else:
+                target_db = self.db_path
+
             # Restore using SQLite backup API
             source_conn = sqlite3.connect(backup_path)
-            target_conn = sqlite3.connect(self.db_path)
+            target_conn = sqlite3.connect(target_db)
             source_conn.backup(target_conn)
             target_conn.close()
             source_conn.close()
 
-            logger.info(f"Restored from backup: {filename}")
+            logger.info(f"Restored from backup: {filename} → {target_db.name}")
             return True
 
         except Exception as e:
@@ -299,6 +327,10 @@ class AutoBackup:
         else:
             interval_display = f"{hours} hour(s)"
 
+        # v2.7.4: Separate counts for memory vs learning backups
+        memory_backups = [b for b in backups if b.get('type') == 'memory']
+        learning_backups = [b for b in backups if b.get('type') == 'learning']
+
         return {
             'enabled': self.config.get('enabled', True),
             'interval_hours': hours,
@@ -307,7 +339,8 @@ class AutoBackup:
             'last_backup': self.config.get('last_backup'),
             'last_backup_file': self.config.get('last_backup_file'),
             'next_backup': next_backup,
-            'backup_count': len(backups),
+            'backup_count': len(memory_backups),
+            'learning_backup_count': len(learning_backups),
             'total_size_mb': round(sum(b['size_mb'] for b in backups), 2),
             'backups': backups,
         }

package/src/learning/adaptive_ranker.py

@@ -296,12 +296,24 @@ class AdaptiveRanker:
 
         context = context or {}
 
+        # Fetch signal stats for features [10-11] (v2.7.4)
+        signal_stats = {}
+        ldb = self._get_learning_db()
+        if ldb:
+            try:
+                memory_ids = [r.get('id') for r in results if r.get('id')]
+                if memory_ids:
+                    signal_stats = ldb.get_signal_stats_for_memories(memory_ids)
+            except Exception:
+                pass  # Signal stats failure is not critical
+
         # Set up feature extraction context (once per query)
         self._feature_extractor.set_context(
             source_scores=context.get('source_scores'),
             tech_preferences=context.get('tech_preferences'),
             current_project=context.get('current_project'),
             workflow_phase=context.get('workflow_phase'),
+            signal_stats=signal_stats,
         )
 
         # Determine phase and route
@@ -406,6 +418,20 @@ class AdaptiveRanker:
             if access_freq >= 0.5:
                 boost *= _RULE_BOOST['high_access']
 
+            # Feature [10]: signal_count (v2.7.4 — feedback volume)
+            if len(features) > 10:
+                signal_count = features[10]
+                if signal_count >= 0.3:  # 3+ signals
+                    boost *= 1.1  # Mild boost for well-known memories
+
+            # Feature [11]: avg_signal_value (v2.7.4 — feedback quality)
+            if len(features) > 11:
+                avg_signal = features[11]
+                if avg_signal >= 0.7:
+                    boost *= 1.15  # Boost memories with positive feedback
+                elif avg_signal < 0.3 and avg_signal > 0.0:
+                    boost *= 0.85  # Penalize memories with negative feedback
+
             # Apply boost to score
             result['score'] = base_score * boost
 
@@ -509,13 +535,56 @@ class AdaptiveRanker:
                 return None
 
             try:
-                self._model = lgb.Booster(model_file=str(MODEL_PATH))
+                model = lgb.Booster(model_file=str(MODEL_PATH))
+
+                # v2.7.4: Check for feature dimension mismatch (10→12 upgrade)
+                model_num_features = model.num_feature()
+                if model_num_features != NUM_FEATURES:
+                    logger.info(
+                        "Feature mismatch: model has %d features, expected %d. "
+                        "Triggering auto-retrain in background.",
+                        model_num_features, NUM_FEATURES,
+                    )
+                    # Delete old model and trigger re-bootstrap
+                    MODEL_PATH.unlink(missing_ok=True)
+                    self._trigger_retrain_background()
+                    return None
+
+                self._model = model
                 logger.info("Loaded ranking model from %s", MODEL_PATH)
                 return self._model
             except Exception as e:
                 logger.warning("Failed to load ranking model: %s", e)
                 return None
 
+    def _trigger_retrain_background(self):
+        """Trigger model re-bootstrap in a background thread (v2.7.4)."""
+        try:
+            import threading
+
+            def _retrain():
+                try:
+                    from .synthetic_bootstrap import SyntheticBootstrapper
+                    bootstrapper = SyntheticBootstrapper()
+                    if bootstrapper.should_bootstrap():
+                        result = bootstrapper.bootstrap_model()
+                        if result:
+                            logger.info(
+                                "Auto-retrain complete with %d-feature model",
+                                NUM_FEATURES,
+                            )
+                            # Reload the new model
+                            with self._lock:
+                                self._model = None
+                                self._model_load_attempted = False
+                except Exception as e:
+                    logger.warning("Auto-retrain failed: %s", e)
+
+            thread = threading.Thread(target=_retrain, daemon=True)
+            thread.start()
+        except Exception:
+            pass
+
     def reload_model(self):
         """
         Force reload of the ranking model from disk.

package/src/learning/feature_extractor.py

@@ -12,23 +12,25 @@ Attribution must be preserved in all copies or derivatives.
 """
 
 """
-FeatureExtractor — Extracts 10-dimensional feature vectors for candidate memories.
+FeatureExtractor — Extracts 12-dimensional feature vectors for candidate memories.
 
 Each memory retrieved during recall gets a feature vector that feeds into
 the AdaptiveRanker. In Phase 1 (rule-based), features drive boosting weights.
 In Phase 2 (ML), features become LightGBM input columns.
 
-Feature Vector (10 dimensions):
-    [0] bm25_score          — Existing retrieval score from search results
-    [1] tfidf_score         — TF-IDF cosine similarity from search results
-    [2] tech_match          — Does memory match user's tech preferences?
-    [3] project_match       — Is memory from the current project?
-    [4] workflow_fit        — Does memory fit current workflow phase?
-    [5] source_quality      — Quality score of the source that created this memory
-    [6] importance_norm     — Normalized importance (importance / 10.0)
-    [7] recency_score       — Exponential decay based on age (180-day half-life)
-    [8] access_frequency    — How often this memory was accessed (capped at 1.0)
-    [9] pattern_confidence  — Max Beta-Binomial confidence from learned patterns
+Feature Vector (12 dimensions):
+    [0]  bm25_score          — Existing retrieval score from search results
+    [1]  tfidf_score         — TF-IDF cosine similarity from search results
+    [2]  tech_match          — Does memory match user's tech preferences?
+    [3]  project_match       — Is memory from the current project?
+    [4]  workflow_fit        — Does memory fit current workflow phase?
+    [5]  source_quality      — Quality score of the source that created this memory
+    [6]  importance_norm     — Normalized importance (importance / 10.0)
+    [7]  recency_score       — Exponential decay based on age (180-day half-life)
+    [8]  access_frequency    — How often this memory was accessed (capped at 1.0)
+    [9]  pattern_confidence  — Max Beta-Binomial confidence from learned patterns
+    [10] signal_count        — Number of feedback signals for this memory (v2.7.4)
+    [11] avg_signal_value    — Average signal value for this memory (v2.7.4)
 
 Design Principles:
     - All features normalized to [0.0, 1.0] range for ML compatibility
@@ -36,6 +38,8 @@ Design Principles:
     - No external API calls — everything computed locally
     - Context (tech preferences, current project) set once per recall batch
     - Thread-safe: no shared mutable state after set_context()
+
+v2.7.4: Expanded from 10 to 12 features. Auto-retrain triggered on mismatch.
 """
 
 import logging
@@ -61,6 +65,8 @@ FEATURE_NAMES = [
     'recency_score',       # 7: Exponential decay based on age
     'access_frequency',    # 8: How often this memory was accessed (capped at 1.0)
     'pattern_confidence',  # 9: Max Beta-Binomial confidence from learned patterns
+    'signal_count',        # 10: Number of feedback signals for this memory (v2.7.4)
+    'avg_signal_value',    # 11: Average signal value for this memory (v2.7.4)
 ]
 
 NUM_FEATURES = len(FEATURE_NAMES)
@@ -102,7 +108,7 @@ _MAX_ACCESS_COUNT = 10
 
 class FeatureExtractor:
     """
-    Extracts 10-dimensional feature vectors for candidate memories.
+    Extracts 12-dimensional feature vectors for candidate memories.
 
     Usage:
         extractor = FeatureExtractor()
@@ -111,9 +117,10 @@ class FeatureExtractor:
             tech_preferences={'python': {'confidence': 0.9}, 'react': {'confidence': 0.7}},
             current_project='SuperLocalMemoryV2',
             workflow_phase='testing',
+            signal_stats={'42': {'count': 5, 'avg_value': 0.8}},
         )
         features = extractor.extract_batch(memories, query="search optimization")
-        # features is List[List[float]], shape (n_memories, 10)
+        # features is List[List[float]], shape (n_memories, 12)
     """
 
     FEATURE_NAMES = FEATURE_NAMES
@@ -129,6 +136,8 @@ class FeatureExtractor:
         self._workflow_keywords: List[str] = []
         # Pattern confidence cache: maps lowercased pattern value -> confidence
         self._pattern_cache: Dict[str, float] = {}
+        # Signal stats cache: maps str(memory_id) -> {count, avg_value} (v2.7.4)
+        self._signal_stats: Dict[str, Dict[str, float]] = {}
 
     def set_context(
         self,
@@ -137,6 +146,7 @@ class FeatureExtractor:
         current_project: Optional[str] = None,
         workflow_phase: Optional[str] = None,
         pattern_confidences: Optional[Dict[str, float]] = None,
+        signal_stats: Optional[Dict[str, Dict[str, float]]] = None,
     ):
         """
         Set context for feature extraction. Called once per recall query.
@@ -154,6 +164,8 @@ class FeatureExtractor:
             pattern_confidences: Map of lowercased pattern value -> confidence (0.0-1.0).
                                  From pattern_learner.PatternStore.get_patterns().
                                  Used for feature [9] pattern_confidence.
+            signal_stats: Map of str(memory_id) -> {count: int, avg_value: float}.
+                          From learning_db feedback aggregation. Used for features [10-11].
         """
         self._source_scores = source_scores or {}
         self._tech_preferences = tech_preferences or {}
@@ -177,9 +189,12 @@ class FeatureExtractor:
         # Cache pattern confidences for feature [9]
         self._pattern_cache = pattern_confidences or {}
 
+        # Cache signal stats for features [10-11] (v2.7.4)
+        self._signal_stats = signal_stats or {}
+
     def extract_features(self, memory: dict, query: str) -> List[float]:
         """
-        Extract 10-dimensional feature vector for a single memory.
+        Extract 12-dimensional feature vector for a single memory.
 
         Args:
             memory: Memory dict from search results. Expected keys:
@@ -188,7 +203,7 @@ class FeatureExtractor:
             query: The recall query string.
 
         Returns:
-            List of 10 floats in [0.0, 1.0] range, one per feature.
+            List of 12 floats in [0.0, 1.0] range, one per feature.
         """
         return [
             self._compute_bm25_score(memory),
@@ -201,6 +216,8 @@ class FeatureExtractor:
             self._compute_recency_score(memory),
             self._compute_access_frequency(memory),
             self._compute_pattern_confidence(memory),
+            self._compute_signal_count(memory),
+            self._compute_avg_signal_value(memory),
         ]
 
     def extract_batch(
@@ -216,7 +233,7 @@ class FeatureExtractor:
             query: The recall query string.
 
         Returns:
-            List of feature vectors (List[List[float]]), shape (n, 10).
+            List of feature vectors (List[List[float]]), shape (n, 12).
             Returns empty list if memories is empty.
         """
         if not memories:
@@ -459,6 +476,43 @@ class FeatureExtractor:
         return min(access_count / float(_MAX_ACCESS_COUNT), 1.0)
 
 
+    def _compute_signal_count(self, memory: dict) -> float:
+        """
+        Number of feedback signals for this memory, normalized to [0, 1].
+
+        Uses cached signal_stats from learning.db. Capped at 10 signals.
+        Memories with more feedback signals are more "known" to the system.
+
+        Returns:
+            min(count / 10.0, 1.0) — 0.0 if no signals, 1.0 if 10+ signals
+            0.0 if no signal stats available (v2.7.3 or earlier)
+        """
+        memory_id = str(memory.get('id', ''))
+        if not memory_id or not self._signal_stats:
+            return 0.0
+
+        stats = self._signal_stats.get(memory_id, {})
+        count = stats.get('count', 0)
+        return min(count / 10.0, 1.0)
+
+    def _compute_avg_signal_value(self, memory: dict) -> float:
+        """
+        Average signal value for this memory.
+
+        Uses cached signal_stats from learning.db. Gives the ranker a direct
+        view of whether this memory's feedback is positive (>0.5) or negative (<0.5).
+
+        Returns:
+            Average signal value (0.0-1.0), or 0.5 (neutral) if no data.
+        """
+        memory_id = str(memory.get('id', ''))
+        if not memory_id or not self._signal_stats:
+            return 0.5  # Neutral default
+
+        stats = self._signal_stats.get(memory_id, {})
+        avg = stats.get('avg_value', 0.5)
+        return max(0.0, min(float(avg), 1.0))
+
     def _compute_pattern_confidence(self, memory: dict) -> float:
         """
         Compute max Beta-Binomial confidence from learned patterns matching this memory.

package/src/learning/feedback_collector.py

@@ -108,6 +108,17 @@ class FeedbackCollector:
         "mcp_used_low": 0.4,
         "cli_useful": 0.9,
         "dashboard_click": 0.8,
+        "dashboard_thumbs_up": 1.0,
+        "dashboard_thumbs_down": 0.0,
+        "dashboard_pin": 1.0,
+        "dashboard_dwell_positive": 0.7,
+        "dashboard_dwell_negative": 0.1,
+        "implicit_positive_timegap": 0.6,
+        "implicit_negative_requick": 0.1,
+        "implicit_positive_reaccess": 0.7,
+        "implicit_positive_post_update": 0.8,
+        "implicit_negative_post_delete": 0.0,
+        "implicit_positive_cross_tool": 0.8,
         "passive_decay": 0.0,
     }
 
@@ -294,6 +305,109 @@ class FeedbackCollector:
             dwell_time=dwell_time,
         )
 
+    # ======================================================================
+    # Channel 4: Implicit Signals (v2.7.4 — auto-collected, zero user effort)
+    # ======================================================================
+
+    def record_implicit_signal(
+        self,
+        memory_id: int,
+        query: str,
+        signal_type: str,
+        source_tool: Optional[str] = None,
+        rank_position: Optional[int] = None,
+    ) -> Optional[int]:
+        """
+        Record an implicit feedback signal inferred from user behavior.
+
+        Called by the signal inference engine in mcp_server.py when it
+        detects behavioral patterns (time gaps, re-queries, re-access, etc.).
+
+        Args:
+            memory_id:     ID of the memory.
+            query:         The recall query (hashed, not stored raw).
+            signal_type:   One of the implicit_* signal types.
+            source_tool:   Which tool originated the query.
+            rank_position: Where the memory appeared in results.
+
+        Returns:
+            Row ID of the feedback record, or None on error.
+        """
+        if not query or signal_type not in self.SIGNAL_VALUES:
+            logger.warning(
+                "record_implicit_signal: invalid query or signal_type=%s",
+                signal_type,
+            )
+            return None
+
+        signal_value = self.SIGNAL_VALUES[signal_type]
+        query_hash = self._hash_query(query)
+        keywords = self._extract_keywords(query)
+
+        return self._store_feedback(
+            query_hash=query_hash,
+            query_keywords=keywords,
+            memory_id=memory_id,
+            signal_type=signal_type,
+            signal_value=signal_value,
+            channel="implicit",
+            source_tool=source_tool,
+            rank_position=rank_position,
+        )
+
+    def record_dashboard_feedback(
+        self,
+        memory_id: int,
+        query: str,
+        feedback_type: str,
+        dwell_time: Optional[float] = None,
+    ) -> Optional[int]:
+        """
+        Record explicit dashboard feedback (thumbs up/down, pin, dwell).
+
+        Args:
+            memory_id:     ID of the memory.
+            query:         The search query active when feedback given.
+            feedback_type: One of 'thumbs_up', 'thumbs_down', 'pin',
+                           'dwell_positive', 'dwell_negative'.
+            dwell_time:    Seconds spent viewing (for dwell signals).
+
+        Returns:
+            Row ID of the feedback record, or None on error.
+        """
+        type_map = {
+            "thumbs_up": "dashboard_thumbs_up",
+            "thumbs_down": "dashboard_thumbs_down",
+            "pin": "dashboard_pin",
+            "dwell_positive": "dashboard_dwell_positive",
+            "dwell_negative": "dashboard_dwell_negative",
+        }
+
+        signal_type = type_map.get(feedback_type)
+        if not signal_type or signal_type not in self.SIGNAL_VALUES:
+            logger.warning(
+                "record_dashboard_feedback: invalid feedback_type=%s",
+                feedback_type,
+            )
+            return None
+
+        if not query:
+            query = f"__dashboard__:{memory_id}"
+
+        signal_value = self.SIGNAL_VALUES[signal_type]
+        query_hash = self._hash_query(query)
+        keywords = self._extract_keywords(query)
+
+        return self._store_feedback(
+            query_hash=query_hash,
+            query_keywords=keywords,
+            memory_id=memory_id,
+            signal_type=signal_type,
+            signal_value=signal_value,
+            channel="dashboard",
+            dwell_time=dwell_time,
+        )
+
     # ======================================================================
     # Passive Decay Tracking
     # ======================================================================