superlocalmemory 3.7.8 → 3.8.1

package/src/superlocalmemory/infra/data_root.py

@@ -11,6 +11,7 @@ explicit process contract and always wins over persisted configuration.
 from __future__ import annotations
 
 import json
+import logging
 import os
 from pathlib import Path
 
@@ -24,6 +25,8 @@ _DURABLE_IDENTITY_NAMES = frozenset(
     },
 )
 
+logger = logging.getLogger(__name__)
+
 
 class DataRootConflictError(RuntimeError):
     """Raised when two state-bearing roots make startup ambiguous."""
@@ -122,17 +125,53 @@ def assert_no_durable_root_conflict(
     *,
     home: str | Path | None = None,
 ) -> None:
-    """Refuse ambiguous startup when selected and default roots hold state.
-
-    This check never writes, copies, or deletes data. A default root that only
-    contains the legacy relocation config is safe and does not trigger it.
+    """Refuse *ambiguous* startup when two state roots make the live namespace unclear.
+
+    The root actually selected for this process is always inspected: an
+    unreadable selected root fails closed. Beyond that, a conflict is only raised
+    when the selection was *implicit* — resolved from the legacy
+    ``config.json:base_dir`` relocation hint — and a separately-populated default
+    root leaves it genuinely ambiguous which namespace is live.
+
+    An explicit environment selection (``SLM_DATA_DIR`` / ``SL_MEMORY_PATH`` /
+    ``SLM_HOME``) is an unambiguous operator contract: a separately-populated
+    default root is then a deliberate multi-root / per-team / second-instance
+    layout, not an ambiguity, so startup proceeds. If the explicitly chosen root
+    is empty while the old default still holds data, that likely-mistyped path is
+    surfaced as a warning rather than a hard block.
+
+    This check never writes, copies, or deletes data.
     """
     home_path = _canonical_path(home if home is not None else Path.home())
     default_root = _canonical_path(home_path / ".superlocalmemory")
     selected_root = canonical_data_root(home=home_path)
     if selected_root == default_root:
         return
+
+    # The root about to be used must be inspectable regardless of how it was
+    # chosen; an unreadable selected root fails closed inside _durable_markers.
     selected_markers = _durable_markers(selected_root)
+
+    if environment_data_root() is not None:
+        # Explicit selection wins; a populated default root is a deliberate
+        # multi-root layout, not an ambiguity. Only warn on the "empty new root
+        # while the old default still holds data" case so a wrong SLM_DATA_DIR
+        # stays visible. Inspection of the unused default never blocks startup.
+        if not selected_markers:
+            try:
+                default_has_data = bool(_durable_markers(default_root))
+            except DataRootConflictError:
+                default_has_data = False
+            if default_has_data:
+                logger.warning(
+                    "SLM_DATA_DIR selects an empty state root (%s) while the "
+                    "default root (%s) still holds data; starting with the empty "
+                    "root as explicitly requested.",
+                    selected_root,
+                    default_root,
+                )
+        return
+
     default_markers = _durable_markers(default_root)
     if not selected_markers or not default_markers:
         return

package/src/superlocalmemory/infra/event_bus.py

@@ -102,13 +102,20 @@ class EventBus:
         logger.info("EventBus initialized: db=%s", self.db_path)
 
     def _init_schema(self) -> None:
-        """Create the memory_events table if it does not exist."""
+        """Create the memory_events table if it does not exist.
+
+        Self-migrates a pre-isolation DB (memory_events without profile_id) so a
+        dashboard viewing profile A never sees profile B's events. This table is
+        store-owned (created here, not by the migration runner), so the store
+        owns its upgrade. Existing rows backfill to the 'default' profile.
+        """
         conn = sqlite3.connect(str(self.db_path))
         try:
             cur = conn.cursor()
             cur.execute("""
                 CREATE TABLE IF NOT EXISTS memory_events (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    profile_id TEXT NOT NULL DEFAULT 'default',
                     event_type TEXT NOT NULL,
                     memory_id INTEGER,
                     source_agent TEXT DEFAULT 'user',
@@ -119,13 +126,42 @@ class EventBus:
                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
                 )
             """)
+            existing = {r[1] for r in cur.execute(
+                "PRAGMA table_info(memory_events)").fetchall()}
+            if "profile_id" not in existing:
+                cur.execute(
+                    "ALTER TABLE memory_events "
+                    "ADD COLUMN profile_id TEXT NOT NULL DEFAULT 'default'"
+                )
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_type ON memory_events(event_type)")
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_created ON memory_events(created_at)")
             cur.execute("CREATE INDEX IF NOT EXISTS idx_events_tier ON memory_events(tier)")
+            cur.execute("CREATE INDEX IF NOT EXISTS idx_events_profile ON memory_events(profile_id, id)")
             conn.commit()
         finally:
             conn.close()
 
+    @staticmethod
+    def _resolve_profile(profile_id: Optional[str]) -> str:
+        """Resolve the active profile for an event when not passed explicitly.
+
+        Uses the request-runtime helper (ContextVar for HTTP, else the
+        profiles.json active_profile cache that every switch keeps in sync) so
+        MCP-in-daemon and CLI emits are attributed correctly too. Lazy import
+        keeps the infra layer free of a hard server dependency; any failure
+        falls back to 'default'.
+        """
+        if profile_id:
+            return profile_id
+        try:
+            from superlocalmemory.server.routes.helpers import get_active_profile
+            resolved = get_active_profile()
+            if resolved:
+                return resolved
+        except Exception:
+            pass
+        return "default"
+
     def emit(
         self,
         event_type: str,
@@ -134,8 +170,14 @@ class EventBus:
         source_agent: str = "user",
         source_protocol: str = "internal",
         importance: int = 5,
+        profile_id: Optional[str] = None,
     ) -> Optional[int]:
-        """Emit an event to all subscribers and persist to database."""
+        """Emit an event to all subscribers and persist to database.
+
+        ``profile_id`` scopes the event to a memory profile. When omitted it is
+        resolved from the active profile so a dashboard viewing one profile
+        never sees another profile's real-time or historical events.
+        """
         if event_type not in VALID_EVENT_TYPES:
             raise ValueError(
                 f"Invalid event type: {event_type}. "
@@ -143,6 +185,7 @@ class EventBus:
             )
 
         importance = max(1, min(10, importance))
+        profile_id = self._resolve_profile(profile_id)
 
         now = datetime.now(timezone.utc).isoformat()
         with self._counter_lock:
@@ -151,6 +194,7 @@ class EventBus:
 
         event: Dict[str, Any] = {
             "seq": seq,
+            "profile_id": profile_id,
             "event_type": event_type,
             "memory_id": memory_id,
             "source_agent": source_agent,
@@ -177,18 +221,24 @@ class EventBus:
             event_type, event_id, memory_id,
         )
 
-        # Auto-prune heuristic
-        self._write_count += 1
-        if (
-            self._write_count >= 100
-            or (datetime.now() - self._last_prune).total_seconds() > 86400
-        ):
+        # Auto-prune heuristic. Decide + reset the counter atomically under the
+        # lock so concurrent emit() calls cannot both cross the threshold and
+        # double-run the prune; run the prune itself OUTSIDE the lock.
+        should_prune = False
+        with self._counter_lock:
+            self._write_count += 1
+            if (
+                self._write_count >= 100
+                or (datetime.now() - self._last_prune).total_seconds() > 86400
+            ):
+                should_prune = True
+                self._write_count = 0
+                self._last_prune = datetime.now()
+        if should_prune:
             try:
                 self.prune_events()
             except Exception:
                 pass
-            self._write_count = 0
-            self._last_prune = datetime.now()
 
         return event_id
 
@@ -202,10 +252,12 @@ class EventBus:
             try:
                 cur = conn.cursor()
                 cur.execute(
-                    "INSERT INTO memory_events (event_type, memory_id, source_agent,"
-                    " source_protocol, payload, importance, tier, created_at)"
-                    " VALUES (?, ?, ?, ?, ?, ?, 'hot', ?)",
-                    (event["event_type"], event.get("memory_id"),
+                    "INSERT INTO memory_events (profile_id, event_type, memory_id,"
+                    " source_agent, source_protocol, payload, importance, tier,"
+                    " created_at)"
+                    " VALUES (?, ?, ?, ?, ?, ?, ?, 'hot', ?)",
+                    (event.get("profile_id", "default"), event["event_type"],
+                     event.get("memory_id"),
                      event["source_agent"], event["source_protocol"],
                      json.dumps(event["payload"]), event["importance"],
                      event["timestamp"]),
@@ -253,9 +305,16 @@ class EventBus:
         since_id: Optional[int] = None,
         limit: int = 50,
         event_type: Optional[str] = None,
+        profile_id: Optional[str] = None,
     ) -> List[dict]:
-        """Get recent events from the database."""
+        """Get recent events from the database, scoped to a profile.
+
+        ``profile_id`` defaults to the active profile so callers never leak
+        another profile's events. Pass ``profile_id="*"`` to bypass scoping
+        (internal maintenance/pruning only — never a client-facing path).
+        """
         limit = min(limit, 200)
+        scope = profile_id if profile_id == "*" else self._resolve_profile(profile_id)
 
         try:
             conn = sqlite3.connect(str(self.db_path))
@@ -263,10 +322,15 @@ class EventBus:
                 cur = conn.cursor()
 
                 query = ("SELECT id, event_type, memory_id, source_agent,"
-                         " source_protocol, payload, importance, tier, created_at"
+                         " source_protocol, payload, importance, tier, created_at,"
+                         " profile_id"
                          " FROM memory_events WHERE 1=1")
                 params: List[Any] = []
 
+                if scope != "*":
+                    query += " AND profile_id = ?"
+                    params.append(scope)
+
                 if since_id is not None:
                     query += " AND id > ?"
                     params.append(since_id)
@@ -293,7 +357,7 @@ class EventBus:
                     "id": row[0], "event_type": row[1], "memory_id": row[2],
                     "source_agent": row[3], "source_protocol": row[4],
                     "payload": parsed, "importance": row[6],
-                    "tier": row[7], "timestamp": row[8],
+                    "tier": row[7], "timestamp": row[8], "profile_id": row[9],
                 })
             return events
 
@@ -306,19 +370,32 @@ class EventBus:
         with self._buffer_lock:
             return [e for e in self._buffer if e.get("seq", 0) > since_seq]
 
-    def get_event_stats(self) -> dict:
-        """Get event system statistics."""
+    def get_event_stats(self, profile_id: Optional[str] = None) -> dict:
+        """Get event system statistics, scoped to a profile.
+
+        ``profile_id`` defaults to the active profile so dashboard event
+        counts never blend across profiles.
+        """
+        scope = self._resolve_profile(profile_id)
         try:
             conn = sqlite3.connect(str(self.db_path))
             try:
                 cur = conn.cursor()
 
-                total = cur.execute("SELECT COUNT(*) FROM memory_events").fetchone()[0]
-                cur.execute("SELECT event_type, COUNT(*) FROM memory_events GROUP BY event_type")
+                total = cur.execute(
+                    "SELECT COUNT(*) FROM memory_events WHERE profile_id = ?",
+                    (scope,)).fetchone()[0]
+                cur.execute(
+                    "SELECT event_type, COUNT(*) FROM memory_events "
+                    "WHERE profile_id = ? GROUP BY event_type", (scope,))
                 by_type = dict(cur.fetchall())
-                cur.execute("SELECT tier, COUNT(*) FROM memory_events GROUP BY tier")
+                cur.execute(
+                    "SELECT tier, COUNT(*) FROM memory_events "
+                    "WHERE profile_id = ? GROUP BY tier", (scope,))
                 by_tier = dict(cur.fetchall())
-                cur.execute("SELECT COUNT(*) FROM memory_events WHERE created_at >= datetime('now', '-24 hours')")
+                cur.execute(
+                    "SELECT COUNT(*) FROM memory_events WHERE profile_id = ? "
+                    "AND created_at >= datetime('now', '-24 hours')", (scope,))
                 last_24h = cur.fetchone()[0]
             finally:
                 conn.close()
@@ -343,7 +420,13 @@ class EventBus:
         warm_hours: int = DEFAULT_WARM_HOURS,
         cold_hours: int = DEFAULT_COLD_HOURS,
     ) -> dict:
-        """Apply tiered retention policy to persisted events."""
+        """Apply tiered retention policy to persisted events.
+
+        INTENTIONALLY GLOBAL (all profiles): this is age/tier-based housekeeping
+        of the shared event log, not a per-tenant read or retention-policy
+        surface. Tenant isolation of event CONTENT is enforced on read via the
+        profile_id filter; this sweep only demotes/expires old rows by age.
+        """
         try:
             conn = sqlite3.connect(str(self.db_path))
             try:

package/src/superlocalmemory/infra/rate_limiter.py

@@ -118,6 +118,22 @@ class RateLimiter:
                 del self._requests[k]
             return len(stale)
 
+    def configure(
+        self,
+        max_requests: int | None = None,
+        window_seconds: int | None = None,
+    ) -> None:
+        """Reconfigure limits at runtime (thread-safe).
+
+        Recorded request timestamps are preserved; only the ceilings change,
+        so a raised limit takes effect immediately for the current window.
+        """
+        with self._lock:
+            if max_requests is not None:
+                self.max_requests = max(1, int(max_requests))
+            if window_seconds is not None:
+                self.window = max(1, int(window_seconds))
+
     def get_stats(self) -> dict:
         """Return a snapshot of limiter state."""
         with self._lock:
@@ -133,3 +149,80 @@ class RateLimiter:
 # ---------------------------------------------------------------------------
 write_limiter = RateLimiter(max_requests=WRITE_LIMIT, window_seconds=WINDOW_SECONDS)
 read_limiter = RateLimiter(max_requests=READ_LIMIT, window_seconds=WINDOW_SECONDS)
+
+
+# ---------------------------------------------------------------------------
+# Runtime-configurable limits (task #47) — dashboard-editable thresholds.
+#
+# The enforcement middleware builds its own limiter instances; it registers
+# them here by role so a single set_limits() call reconfigures every live
+# limiter at once (no restart). Loopback limiters derive from write/read,
+# matching the startup derivation in unified_daemon.
+# ---------------------------------------------------------------------------
+
+_MANAGED: List[Tuple[str, "RateLimiter"]] = []
+_MANAGED_LOCK = threading.Lock()
+_CURRENT: Dict[str, int] = {
+    "write": WRITE_LIMIT, "read": READ_LIMIT, "window": WINDOW_SECONDS,
+}
+
+
+def _loopback_write(write: int) -> int:
+    return max(300, int(write) * 10)
+
+
+def _loopback_read(read: int) -> int:
+    return max(2000, int(read) * 20)
+
+
+def register_managed(role: str, limiter: "RateLimiter") -> None:
+    """Register an enforcement limiter so set_limits() can reconfigure it.
+
+    role is one of: 'write', 'read', 'lb_write', 'lb_read'.
+    """
+    with _MANAGED_LOCK:
+        _MANAGED.append((role, limiter))
+
+
+def reset_managed() -> None:
+    """Drop all registered limiters (app teardown / test isolation)."""
+    with _MANAGED_LOCK:
+        _MANAGED.clear()
+
+
+def get_limits() -> Dict[str, int]:
+    """Return the current effective write/read/window limits."""
+    with _MANAGED_LOCK:
+        return dict(_CURRENT)
+
+
+def set_limits(
+    write: int | None = None,
+    read: int | None = None,
+    window: int | None = None,
+) -> Dict[str, int]:
+    """Update limits and reconfigure every registered limiter live.
+
+    Partial updates are supported (pass only what changes). Loopback
+    limiters re-derive from the new write/read. Returns the new effective
+    limits. Values are floored at 1.
+    """
+    with _MANAGED_LOCK:
+        if write is not None:
+            _CURRENT["write"] = max(1, int(write))
+        if read is not None:
+            _CURRENT["read"] = max(1, int(read))
+        if window is not None:
+            _CURRENT["window"] = max(1, int(window))
+        w, r, win = _CURRENT["write"], _CURRENT["read"], _CURRENT["window"]
+        lb_w, lb_r = _loopback_write(w), _loopback_read(r)
+        for role, limiter in _MANAGED:
+            if role == "write":
+                limiter.configure(max_requests=w, window_seconds=win)
+            elif role == "read":
+                limiter.configure(max_requests=r, window_seconds=win)
+            elif role == "lb_write":
+                limiter.configure(max_requests=lb_w, window_seconds=win)
+            elif role == "lb_read":
+                limiter.configure(max_requests=lb_r, window_seconds=win)
+        return dict(_CURRENT)

package/src/superlocalmemory/ingestion/adapter_manager.py

@@ -175,7 +175,10 @@ def stop_adapter(name: str) -> dict:
         proc.terminate()
         proc.wait(timeout=10)
     except ImportError:
-        os.kill(pid, 15)  # SIGTERM
+        # No psutil: best-effort termination. On Windows os.kill(pid, 15) maps to
+        # TerminateProcess (a hard kill, not a graceful SIGTERM) — psutil's
+        # terminate() does the same there, so behavior is equivalent either way.
+        os.kill(pid, 15)
     except Exception:
         pass
 

package/src/superlocalmemory/ingestion/credentials.py

@@ -42,7 +42,7 @@ def store_credential(service: str, key: str, value: str) -> bool:
     except Exception:
         pass
 
-    # Fallback: encrypted file with restricted permissions
+    # Fallback: restricted-permission file (0600) when no OS keychain is present
     try:
         cred_dir = _credential_dir()
         cred_dir.mkdir(parents=True, exist_ok=True)

package/src/superlocalmemory/learning/cross_project.py

@@ -65,6 +65,7 @@ TECH_CATEGORIES: dict[str, list[str]] = {
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS transferable_patterns (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id TEXT NOT NULL DEFAULT 'default',
     pattern_type TEXT NOT NULL DEFAULT 'preference',
     key TEXT NOT NULL,
     value TEXT NOT NULL,
@@ -75,7 +76,7 @@ CREATE TABLE IF NOT EXISTS transferable_patterns (
     contradictions TEXT DEFAULT '[]',
     first_seen TEXT,
     last_seen TEXT,
-    UNIQUE(pattern_type, key)
+    UNIQUE(profile_id, pattern_type, key)
 );
 
 CREATE TABLE IF NOT EXISTS memories (
@@ -115,25 +116,29 @@ class CrossProjectAggregator:
         # Step 2: Merge with temporal decay
         merged = self._merge_with_decay(profile_patterns)
 
-        # Step 3: Detect contradictions
+        # Step 3: Detect contradictions (scoped to the target profile)
         for key, pattern_data in merged.items():
             pattern_data["contradictions"] = self._detect_contradictions(
-                key, pattern_data
+                key, pattern_data, target_profile
             )
 
-        # Step 4: Store and return
-        self._store_patterns(merged)
+        # Step 4: Store and return (scoped to the target profile)
+        self._store_patterns(merged, target_profile)
         return [{"key": k, **v} for k, v in merged.items()]
 
-    def get_preferences(self, min_confidence: float = 0.6) -> dict[str, dict]:
-        """Retrieve stored transferable preferences above *min_confidence*."""
+    def get_preferences(
+        self,
+        profile_id: str = "default",
+        min_confidence: float = 0.6,
+    ) -> dict[str, dict]:
+        """Retrieve stored transferable preferences for *profile_id* above *min_confidence*."""
         conn = sqlite3.connect(str(self._db_path))
         conn.row_factory = sqlite3.Row
         try:
             cur = conn.execute(
                 "SELECT * FROM transferable_patterns "
-                "WHERE confidence >= ? ORDER BY confidence DESC",
-                (min_confidence,),
+                "WHERE profile_id = ? AND confidence >= ? ORDER BY confidence DESC",
+                (profile_id, min_confidence),
             )
             result: dict[str, dict] = {}
             for row in cur.fetchall():
@@ -277,18 +282,18 @@ class CrossProjectAggregator:
         }
 
     def _detect_contradictions(
-        self, pattern_key: str, pattern_data: dict
+        self, pattern_key: str, pattern_data: dict, profile_id: str = "default"
     ) -> list[str]:
         contradictions: list[str] = []
 
-        # Check stored value vs new value
+        # Check stored value vs new value, scoped to this profile.
         conn = sqlite3.connect(str(self._db_path))
         conn.row_factory = sqlite3.Row
         try:
             cur = conn.execute(
                 "SELECT value, last_seen FROM transferable_patterns "
-                "WHERE key = ? AND pattern_type = 'preference'",
-                (pattern_key,),
+                "WHERE profile_id = ? AND key = ? AND pattern_type = 'preference'",
+                (profile_id, pattern_key),
             )
             row = cur.fetchone()
             if row:
@@ -316,18 +321,21 @@ class CrossProjectAggregator:
         finally:
             conn.close()
 
-    def _store_patterns(self, merged: dict[str, dict]) -> None:
+    def _store_patterns(
+        self, merged: dict[str, dict], profile_id: str = "default"
+    ) -> None:
+        """Persist merged patterns for *profile_id*. Each profile has isolated rows."""
         conn = sqlite3.connect(str(self._db_path))
         now = datetime.now(UTC).isoformat()
         try:
             for key, data in merged.items():
                 conn.execute(
                     """INSERT INTO transferable_patterns
-                       (pattern_type, key, value, confidence, evidence_count,
-                        profiles_seen, decay_factor, contradictions,
-                        first_seen, last_seen)
-                       VALUES ('preference', ?, ?, ?, ?, ?, ?, ?, ?, ?)
-                       ON CONFLICT(pattern_type, key) DO UPDATE SET
+                       (profile_id, pattern_type, key, value, confidence,
+                        evidence_count, profiles_seen, decay_factor,
+                        contradictions, first_seen, last_seen)
+                       VALUES (?, 'preference', ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                       ON CONFLICT(profile_id, pattern_type, key) DO UPDATE SET
                            value = excluded.value,
                            confidence = excluded.confidence,
                            evidence_count = excluded.evidence_count,
@@ -337,6 +345,7 @@ class CrossProjectAggregator:
                            last_seen = excluded.last_seen
                     """,
                     (
+                        profile_id,
                         key,
                         data["value"],
                         data["confidence"],

package/src/superlocalmemory/learning/model_rollback.py

@@ -34,6 +34,8 @@ import sqlite3
 from datetime import datetime, timedelta, timezone
 from typing import Final
 
+from superlocalmemory.learning.model_cache import invalidate as invalidate_model_cache
+
 logger = logging.getLogger(__name__)
 
 
@@ -235,6 +237,7 @@ class ModelRollback:
                 )
                 return False
 
+        invalidate_model_cache(self._profile_id)
         logger.warning(
             "AUTO-ROLLBACK profile=%s reason=%s observations=%d "
             "baseline_ndcg=%.4f current_ndcg=%.4f",

package/src/superlocalmemory/learning/ranker_retrain_online.py

@@ -33,6 +33,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Final
 
+from superlocalmemory.learning.model_cache import invalidate as invalidate_model_cache
 from superlocalmemory.learning.ranker_common import (
     _build_training_matrix,
     _compute_eval_metrics,
@@ -389,6 +390,7 @@ def _promote_candidate(
                 (json.dumps(meta), candidate_id),
             )
             conn.commit()
+            invalidate_model_cache(profile_id)
             return True
         except sqlite3.Error as exc:
             conn.rollback()

package/src/superlocalmemory/learning/reward.py

@@ -73,6 +73,24 @@ _DWELL_MAX_MS: Final[int] = 3_600_000  # 1 h
 _BUSY_TIMEOUT_MS: Final[int] = 50
 
 
+def _feed_source_quality(
+    memory_db_path: Path,
+    rewards: list[tuple[str, str, list[str], float]],
+) -> None:
+    """Fail-soft provenance bridge kept outside the reward transaction."""
+    try:
+        from superlocalmemory.learning.source_quality import (
+            update_source_quality_for_reward_batch,
+        )
+        update_source_quality_for_reward_batch(
+            memory_db_path=memory_db_path,
+            learning_db_path=memory_db_path.parent / "learning.db",
+            rewards=rewards,
+        )
+    except Exception as exc:  # noqa: BLE001 - reward finalization must survive
+        logger.debug("source-quality reward feed failed (non-fatal): %s", exc)
+
+
 # ---------------------------------------------------------------------------
 # Signal contract — names match the manifest A.1 label formula.
 # ---------------------------------------------------------------------------
@@ -604,6 +622,7 @@ class EngagementRewardModel:
                 # lock-scope — SQLite rows are tied to the connection.
                 _pid = pending["profile_id"]
                 _qid = pending["recall_query_id"]
+                _facts_json = str(pending["fact_ids_json"] or "[]")
         except sqlite3.Error as exc:
             logger.debug("finalize_outcome SQLite error: %s", exc)
             return _FALLBACK_REWARD
@@ -633,6 +652,21 @@ class EngagementRewardModel:
             except Exception as exc:  # noqa: BLE001 — defence in depth
                 logger.debug("feed_recall_settled failed (non-fatal): %s", exc)
 
+        try:
+            _fact_ids = json.loads(_facts_json)
+            if not isinstance(_fact_ids, list):
+                _fact_ids = []
+        except (TypeError, ValueError, json.JSONDecodeError):
+            _fact_ids = []
+        _feed_source_quality(
+            self._db,
+            [(
+                str(_pid),
+                str(outcome_id),
+                [str(fid) for fid in _fact_ids if fid],
+                float(reward),
+            )],
+        )
         return reward
 
     # ------------------------------------------------------------------
@@ -749,6 +783,22 @@ class EngagementRewardModel:
                     except sqlite3.Error:
                         conn.execute("ROLLBACK")
                         raise
+                reward_sources = []
+                for item in i_chunk:
+                    try:
+                        fact_ids = json.loads(str(item[2] or "[]"))
+                    except (TypeError, ValueError, json.JSONDecodeError):
+                        fact_ids = []
+                    reward_sources.append((
+                        str(item[1]),
+                        str(item[0]),
+                        (
+                            [str(fid) for fid in fact_ids if fid]
+                            if isinstance(fact_ids, list) else []
+                        ),
+                        float(item[4]),
+                    ))
+                _feed_source_quality(self._db, reward_sources)
         except sqlite3.Error as exc:  # pragma: no cover — defensive
             logger.debug("reap_stale SQLite error: %s", exc)
             return written