superlocalmemory 2.7.2 → 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/graph_engine.py

@@ -297,12 +297,11 @@ class ClusterBuilder:
         Returns:
             Number of clusters created
         """
-        # Import igraph modules here to avoid conflicts
-        try:
-            import igraph as ig
-            import leidenalg
-        except ImportError:
-            raise ImportError("python-igraph and leidenalg required. Install: pip install python-igraph leidenalg")
+        if not IGRAPH_AVAILABLE:
+            logger.warning("igraph/leidenalg not installed. Graph clustering disabled. Install with: pip3 install python-igraph leidenalg")
+            return 0
+        import igraph as ig
+        import leidenalg
 
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -457,11 +456,11 @@ class ClusterBuilder:
         Returns:
             Dictionary with hierarchical clustering statistics
         """
-        try:
-            import igraph as ig
-            import leidenalg
-        except ImportError:
-            raise ImportError("python-igraph and leidenalg required. Install: pip install python-igraph leidenalg")
+        if not IGRAPH_AVAILABLE:
+            logger.warning("igraph/leidenalg not installed. Hierarchical clustering disabled. Install with: pip3 install python-igraph leidenalg")
+            return {'subclusters_created': 0, 'depth_reached': 0}
+        import igraph as ig
+        import leidenalg
 
         conn = sqlite3.connect(self.db_path)
         cursor = conn.cursor()
@@ -512,6 +511,8 @@ class ClusterBuilder:
                                profile: str, min_size: int, max_depth: int,
                                current_depth: int) -> Tuple[int, int]:
         """Recursively sub-cluster a community using Leiden."""
+        if not IGRAPH_AVAILABLE:
+            return 0, current_depth - 1
         import igraph as ig
         import leidenalg
 
@@ -1038,6 +1039,9 @@ class GraphEngine:
                 'summaries_generated': summaries,
                 'time_seconds': round(elapsed, 2)
             }
+            if not IGRAPH_AVAILABLE:
+                stats['warning'] = 'igraph/leidenalg not installed — graph built without clustering. Install with: pip3 install python-igraph leidenalg'
+
 
             logger.info(f"Graph build complete: {stats}")
             return stats

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,22 +12,25 @@ Attribution must be preserved in all copies or derivatives.
 """
 
 """
-FeatureExtractor — Extracts 9-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 (9 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)
+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
@@ -35,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
@@ -59,6 +64,9 @@ FEATURE_NAMES = [
     'importance_norm',     # 6: Normalized importance (importance / 10.0)
     '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)
@@ -100,7 +108,7 @@ _MAX_ACCESS_COUNT = 10
 
 class FeatureExtractor:
     """
-    Extracts 9-dimensional feature vectors for candidate memories.
+    Extracts 12-dimensional feature vectors for candidate memories.
 
     Usage:
         extractor = FeatureExtractor()
@@ -109,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, 9)
+        # features is List[List[float]], shape (n_memories, 12)
     """
 
     FEATURE_NAMES = FEATURE_NAMES
@@ -125,6 +134,10 @@ class FeatureExtractor:
         self._current_project_lower: Optional[str] = None
         self._workflow_phase: Optional[str] = None
         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,
@@ -132,6 +145,8 @@ class FeatureExtractor:
         tech_preferences: Optional[Dict[str, dict]] = None,
         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.
@@ -146,6 +161,11 @@ class FeatureExtractor:
                               From cross_project_aggregator or pattern_learner.
             current_project: Name of the currently active project (if detected).
             workflow_phase: Current workflow phase (planning, coding, testing, etc).
+            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 {}
@@ -166,9 +186,15 @@ class FeatureExtractor:
             if workflow_phase else []
         )
 
+        # 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 9-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:
@@ -177,7 +203,7 @@ class FeatureExtractor:
             query: The recall query string.
 
         Returns:
-            List of 9 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),
@@ -189,6 +215,9 @@ class FeatureExtractor:
             self._compute_importance_norm(memory),
             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(
@@ -204,7 +233,7 @@ class FeatureExtractor:
             query: The recall query string.
 
         Returns:
-            List of feature vectors (List[List[float]]), shape (n, 9).
+            List of feature vectors (List[List[float]]), shape (n, 12).
             Returns empty list if memories is empty.
         """
         if not memories:
@@ -447,6 +476,92 @@ 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.
+
+        Looks up the cached pattern_confidences (set via set_context) and checks
+        if any pattern value appears in the memory's content or tags. Returns the
+        maximum confidence among all matching patterns.
+
+        Returns:
+            Max confidence (0.0-1.0) from matching patterns
+            0.5 if no patterns loaded (neutral — unknown)
+            0.0 if patterns loaded but none match
+        """
+        if not self._pattern_cache:
+            return 0.5  # No patterns available — neutral
+
+        content = memory.get('content', '')
+        if not content:
+            return 0.0
+
+        content_lower = content.lower()
+
+        # Also check tags
+        tags_str = ''
+        tags = memory.get('tags', [])
+        if isinstance(tags, list):
+            tags_str = ' '.join(t.lower() for t in tags)
+        elif isinstance(tags, str):
+            tags_str = tags.lower()
+
+        searchable = content_lower + ' ' + tags_str
+
+        max_confidence = 0.0
+        for pattern_value, confidence in self._pattern_cache.items():
+            # Pattern values are already lowercased in the cache
+            pattern_lower = pattern_value.lower() if pattern_value else ''
+            if not pattern_lower:
+                continue
+            # Word-boundary check for short patterns to avoid false positives
+            if len(pattern_lower) <= 3:
+                if re.search(r'\b' + re.escape(pattern_lower) + r'\b', searchable):
+                    max_confidence = max(max_confidence, confidence)
+            else:
+                if pattern_lower in searchable:
+                    max_confidence = max(max_confidence, confidence)
+
+        return max(0.0, min(max_confidence, 1.0))
+
+
 # ============================================================================
 # Module-level convenience functions
 # ============================================================================

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
     # ======================================================================