superlocalmemory 4.0.9 → 4.1.0

package/src/superlocalmemory/graph/cozo_backend.py

@@ -5,7 +5,16 @@
 """SuperLocalMemory v3.4.5 — CozoDB Graph Backend.
 
 Embedded graph database backend powered by CozoDB (MPL-2.0).
-Replaces NetworkX for entity graph storage and traversal.
+
+It stores the graph. It does not traverse it, and the line that used to claim it
+replaced NetworkX "for storage and traversal" outlived the traversal by a
+release: the walk lives once in ``retrieval/spreading``, as a pure function of an
+adjacency snapshot, and is numpy rather than NetworkX either way. What this
+module supplies is the snapshot's edges, read by
+``graph/cozo_adjacency.CozoAdjacencySource`` -- measured at 395 ms against
+SQLite's 2,477 ms on a 208,151-edge store. Both figures come from a hand run on a
+copy of that store, recorded in ``cozo_adjacency``; nothing in the test suite
+reproduces them.
 
 All Datalog queries are private to this module.
 External code calls Python methods only — never raw Datalog strings.
@@ -277,6 +286,64 @@ class CozoDBGraphBackend:
             :rm edge {from_id, to_id, edge_type => weight, metadata, profile_id, created_at}
         """, {"fact_id": fact_id})
 
+    def remove_entity(self, entity_id: str) -> None:
+        """Remove an entity node and every bridge that reaches it.
+
+        ``remove_fact`` clears a fact's bridges and edges and leaves the entity
+        nodes alone, which is right when a fact is deleted -- the entity is
+        still real and other facts still reference it. It is wrong when the
+        entity itself is erased: the node stayed behind with its name in it,
+        so a graph query could still name somebody after their record had been
+        removed from the store.
+
+        The id is bound as a parameter, so an entity name containing a quote
+        cannot become query text.
+        """
+        self._db.run("""
+            ?[fact_id, entity_id, profile_id] :=
+                *fact_entity{fact_id, entity_id, profile_id}, entity_id = $entity_id
+            :rm fact_entity {fact_id, entity_id => profile_id}
+        """, {"entity_id": entity_id})
+        self._db.run("""
+            ?[from_id, to_id, edge_type, weight, metadata, profile_id, created_at] :=
+                *edge{from_id, to_id, edge_type, weight, metadata, profile_id, created_at},
+                (from_id = $entity_id or to_id = $entity_id)
+            :rm edge {from_id, to_id, edge_type => weight, metadata, profile_id, created_at}
+        """, {"entity_id": entity_id})
+        self._db.run("""
+            ?[id, name, entity_type, tier, properties, profile_id,
+              created_at, updated_at] :=
+                *entity{id, name, entity_type, tier, properties, profile_id,
+                        created_at, updated_at},
+                id = $entity_id
+            :rm entity {id => name, entity_type, tier, properties, profile_id,
+                        created_at, updated_at}
+        """, {"entity_id": entity_id})
+
+    def remove_fact_candidacy(self, fact_id: str) -> None:
+        """Stop a fact being *offered* as a candidate, without touching the graph.
+
+        Removes only the ``fact_entity`` bridge. The fact's edges stay.
+
+        The two are not the same thing and the SQLite channel already treats them
+        differently. Its entity map filters on ``visible_fact_clause()`` — a
+        withheld row must never enter it, because it carries its whole cluster's
+        pooled entity list and out-ranks real memories. Its edge walk filters on
+        scope only, with no visibility predicate at all, so it traverses edges to
+        withheld and archived facts and lets hydration drop them at the end.
+
+        So a projection that deleted a hidden fact's edges would hold a smaller
+        adjacency than the walk it is meant to replace, and give different
+        answers for every fact that happened to neighbour a withheld one. Use
+        this for a fact that has become invisible; use ``remove_fact`` only for
+        one that is genuinely gone.
+        """
+        self._db.run("""
+            ?[fact_id, entity_id, profile_id] :=
+                *fact_entity{fact_id, entity_id, profile_id}, fact_id = $fact_id
+            :rm fact_entity {fact_id, entity_id => profile_id}
+        """, {"fact_id": fact_id})
+
     def record_shadow_comparison(
         self,
         *,
@@ -346,9 +413,24 @@ class CozoDBGraphBackend:
 
         # Step 2: Export fact-to-canonical-entity mappings.  This relation is
         # what allows a canonical query seed to enter the fact graph.
-        facts_sql = """
+        #
+        # Withheld and archived facts are excluded, with the same predicate the
+        # SQLite entity map uses and for the reason it records: such a row
+        # carries its whole cluster's pooled entity list, so it out-ranks real
+        # memories, takes the top-k budget, and is then discarded at hydration.
+        # This export predated that fix. Measured on a copy of the author's
+        # store, it had put 1,257 unreturnable facts into the bridge, and the
+        # Cozo graph search diverged from SQLite on every query tried — one
+        # returned 9 results against SQLite's 20. The projection failed closed
+        # each time, so recall stayed correct and the projection was useless.
+        from superlocalmemory.storage.database import (
+            visible_fact_clause_for_connection,
+        )
+
+        facts_sql = f"""
             SELECT fact_id, canonical_entities_json
             FROM atomic_facts WHERE profile_id = ?
+            {visible_fact_clause_for_connection(conn)}
         """
         fact_entity_dicts: list[dict[str, str]] = []
         for fact_id, raw_entities in conn.execute(facts_sql, (profile_id,)).fetchall():
@@ -386,142 +468,25 @@ class CozoDBGraphBackend:
 
         return len(edge_dicts)
 
-    def recall_facts(
-        self,
-        seed_entity_ids: list[str],
-        *,
-        profile_id: str = "default",
-        depth: int = 4,
-        decay: float = 0.7,
-        threshold: float = 0.05,
-        top_k: int = 50,
-    ) -> list[tuple[str, float]]:
-        """Mirror SLM's entity-to-fact/fact-graph activation in Cozo storage.
-
-        Query values never enter Datalog source.  Cozo is used as the durable
-        projection; activation runs in Python so the algorithm stays aligned
-        with the SQLite in-memory channel and can be shadow-compared exactly.
-        """
-        if not seed_entity_ids:
-            return []
-        entity_rows = self._db.run(
-            "?[fact_id, entity_id] := *fact_entity{fact_id, entity_id, profile_id}, profile_id = $profile_id",
-            {"profile_id": profile_id},
-        )
-        edge_rows = self._db.run(
-            "?[from_id, to_id, weight] := *edge{from_id, to_id, weight, profile_id}, profile_id = $profile_id",
-            {"profile_id": profile_id},
-        )
-        entity_to_facts: dict[str, list[str]] = {}
-        fact_to_entities: dict[str, list[str]] = {}
-        for fact_id, entity_id in entity_rows.values.tolist() if len(entity_rows) else []:
-            entity_to_facts.setdefault(str(entity_id), []).append(str(fact_id))
-            fact_to_entities.setdefault(str(fact_id), []).append(str(entity_id))
-        adjacency: dict[str, list[tuple[str, float]]] = {}
-        for source_id, target_id, weight in edge_rows.values.tolist() if len(edge_rows) else []:
-            source, target = str(source_id), str(target_id)
-            # Match EntityGraphChannel: graph edges are bidirectional during
-            # activation even when stored as directed rows.
-            adjacency.setdefault(source, []).append((target, float(weight)))
-            adjacency.setdefault(target, []).append((source, float(weight)))
-
-        activation: dict[str, float] = {}
-        visited_entities = set(seed_entity_ids)
-        for entity_id in seed_entity_ids:
-            for fact_id in entity_to_facts.get(entity_id, ()):
-                activation[fact_id] = max(activation.get(fact_id, 0.0), 1.0)
-        frontier = set(activation)
-        for hop in range(1, depth):
-            hop_decay = decay ** hop
-            if hop_decay < threshold:
-                break
-            next_frontier: set[str] = set()
-            for fact_id in frontier:
-                for neighbor_id, _weight in adjacency.get(fact_id, ()):
-                    # SQLite intentionally ignores edge weights when graph
-                    # metrics are unavailable; use that same baseline here.
-                    score = activation[fact_id] * decay
-                    if score >= threshold and score > activation.get(neighbor_id, 0.0):
-                        activation[neighbor_id] = score
-                        next_frontier.add(neighbor_id)
-            for fact_id in frontier:
-                for entity_id in fact_to_entities.get(fact_id, ()):
-                    if entity_id in visited_entities:
-                        continue
-                    visited_entities.add(entity_id)
-                    for related_fact_id in entity_to_facts.get(entity_id, ()):
-                        if hop_decay > activation.get(related_fact_id, 0.0):
-                            activation[related_fact_id] = hop_decay
-                            next_frontier.add(related_fact_id)
-            frontier = next_frontier
-            if not frontier:
-                break
-        results = [(fact_id, score) for fact_id, score in activation.items() if score >= threshold]
-        if not results:
-            return []
-        maximum = max(score for _, score in results)
-        results = [(fact_id, score / maximum) for fact_id, score in results]
-        return sorted(results, key=lambda item: item[1], reverse=True)[:top_k]
-
-    # ------------------------------------------------------------------
-    # Spreading Activation (Python BFS over CozoDB edges)
-    # ------------------------------------------------------------------
-
-    def spreading_activation(
-        self,
-        seed_entities: list[str],
-        depth: int = 3,
-        decay: float = 0.5,
-        top_k: int = 50,
-    ) -> list[tuple[str, float]]:
-        """BFS from seed nodes with weight decay per hop.
-
-        Uses CozoDB as fast edge store, Python for BFS logic.
-        Returns [(entity_id, activation_score), ...] sorted by score desc.
-        """
-        if not seed_entities:
-            return []
-
-        scores: dict[str, float] = {}
-        current_frontier: set[str] = set(seed_entities)
-        for s in seed_entities:
-            scores[s] = 1.0
-
-        for d in range(depth):
-            if not current_frontier:
-                break
-            next_frontier: set[str] = set()
-            hop_multiplier = decay ** (d + 1)
-
-            for entity_id in current_frontier:
-                # Query all outgoing edges from this entity
-                try:
-                    result = self._db.run("""
-                        ?[to_id, weight] :=
-                            *edge{from_id, to_id, weight}, from_id = $entity_id
-                    """, {"entity_id": entity_id})
-                    df = result if hasattr(result, "values") else result
-                    if df is None or len(df) == 0:
-                        continue
-                    rows = df.values.tolist() if hasattr(df, "values") else []
-                    for to_id, weight in rows:
-                        to_id_str = str(to_id)
-                        score = hop_multiplier * float(weight)
-                        if to_id_str not in scores or score > scores[to_id_str]:
-                            scores[to_id_str] = score
-                        next_frontier.add(to_id_str)
-                except Exception:
-                    continue
-
-            current_frontier = next_frontier
-
-        # Sort by score desc, return top_k
-        ranked = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-        return ranked[:top_k]
-
-    # ------------------------------------------------------------------
-    # PageRank (Python iterative over CozoDB edges)
-    # ------------------------------------------------------------------
+    # recall_facts() and spreading_activation() were here, and they were a
+    # second implementation of the walk in retrieval/entity_channel.py. They did
+    # not compute the same function: the channel multiplies activation by a
+    # PageRank factor every hop and these did not, so on a real store 3,567 of
+    # 3,667 shared facts came out with different scores, the result sets
+    # differed, and the projected path failed its shadow comparison on every
+    # query and fell back to SQLite. The projection was correct data that
+    # nothing could use.
+    #
+    # spreading_activation() also queried Cozo once per frontier node: 200
+    # single-node queries measured 18,125 ms against 303 ms for one batched
+    # query returning the identical 6,046 rows. With a mean degree of 228 over
+    # four hops that is minutes per recall.
+    #
+    # The walk now lives in retrieval/spreading.py, once, as a pure function of
+    # an AdjacencySnapshot. A storage backend supplies adjacency, not answers —
+    # which is also why there is no longer anything to shadow-compare. Do not
+    # reintroduce a traversal here; add an AdjacencySource adapter instead
+    # (retrieval/graph_adjacency.py).
 
     def pagerank(
         self, damping: float = 0.85, max_iter: int = 100

package/src/superlocalmemory/hooks/portable_kit.py

@@ -38,9 +38,17 @@ SLM_MARKER_END = "<!-- SLM-END -->"
 # "http-mcp-remote" — mcp-remote stdio bridge for stdio-only clients.
 VALID_TRANSPORTS: frozenset[str] = frozenset({"stdio", "http", "http-mcp-remote"})
 
+#: The commands below are Claude Code's own, not ours -- ``slm`` has no
+#: ``plugin`` subcommand and never has, so the instruction this used to print
+#: ended at ``invalid choice: 'plugin'`` with nothing else offered. The working
+#: path already existed in ``cli/setup_wizard.py``; it just was not the one
+#: anybody was told about.
 CLAUDE_CODE_PLUGIN_POINTER = (
-    "slm connect claude-code: Claude Code is configured via the SLM plugin (see plugin/ directory).\n"
-    "Run: slm plugin install  OR  see plugin-src/ for manual installation.\n"
+    "slm connect claude-code: Claude Code is configured via the SLM plugin, "
+    "which Claude Code installs itself.\n"
+    "Run:  claude plugin marketplace add qualixar/superlocalmemory\n"
+    "then: claude plugin install superlocalmemory@qualixar\n"
+    "Or run `slm setup` to do both, or see plugin-src/ to install by hand.\n"
     "No MCP config file is written by this command."
 )
 

package/src/superlocalmemory/learning/bandit.py

@@ -22,6 +22,7 @@ All SQL is parameterised — grep guard in CI ensures no f-string SQL here.
 
 from __future__ import annotations
 
+import json
 import logging
 import os
 import secrets
@@ -30,6 +31,7 @@ import threading
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
+from collections.abc import Sequence
 from typing import Any
 
 from superlocalmemory.learning.arm_catalog import ARM_CATALOG
@@ -40,6 +42,11 @@ from superlocalmemory.learning.bandit_cache import (
 
 logger = logging.getLogger(__name__)
 
+#: How many shown fact_ids a play records. The settler reads the top 3; the
+#: extra two are headroom for a reranker that reorders after the play is
+#: written, and a bound so this cannot become an unread blob on a hot path.
+_SHOWN_FACT_LIMIT = 5
+
 _FALLBACK_ARM_ID = "fallback_default"
 
 _DEFAULT_ALPHA_CAP = float(os.environ.get("SLM_BANDIT_ALPHA_CAP", "1000.0"))
@@ -402,6 +409,42 @@ class ContextualBandit:
             pass
         return True
 
+    def record_shown(self, play_id: int, fact_ids: Sequence[str]) -> bool:
+        """Record which memories this play surfaced, for later settlement.
+
+        A play is settled from evidence — did anything downstream reference a
+        memory this query returned? The settler used to answer "which memories"
+        by reading ``learning_signals`` for the same ``query_id``, and those
+        rows are written by an enqueue that is deliberately off (it costs twenty
+        rows per query and inflated the ranking-phase counter 2,675x). With no
+        evidence to look for, every settlement fell through to the 120-second
+        neutral default of 0.5, which is why 165 arms all read alpha == beta.
+
+        So the play carries its own evidence. Best-effort by design: the reward
+        is a nicety and a recall is not. A failure here means this one play
+        settles as ``default``, exactly as before.
+
+        Bounded to the first few ids because the settler only ever reads the
+        top of the list, and an unbounded JSON blob on the recall path is a
+        write cost with no reader.
+        """
+        if not play_id:
+            return False
+        ids = [str(f) for f in list(fact_ids)[:_SHOWN_FACT_LIMIT] if f]
+        if not ids:
+            return False
+        try:
+            conn = _conn_for(self._db_path)
+            conn.execute(
+                "UPDATE bandit_plays SET shown_fact_ids = ? WHERE play_id = ?",
+                (json.dumps(ids), int(play_id)),
+            )
+            return True
+        except sqlite3.Error as exc:
+            # Includes "no such column" on a store where M044 has not run.
+            logger.debug("bandit.record_shown: %s", exc)
+            return False
+
     # ------------------------------------------------------------------
     # snapshot (for dashboard — LLD-04 consumer)
     # ------------------------------------------------------------------

package/src/superlocalmemory/learning/consolidation_worker.py

@@ -96,6 +96,41 @@ __all__ = (
 # ---------------------------------------------------------------------------
 
 
+#: Distinct informative labels required before a retrain is worth running.
+#:
+#: Measured on a live production store: ``learning_features`` holds 5,352 rows, of
+#: which **5,350 carry label 0.0** and exactly two are non-zero (0.6 and 1.0) —
+#: the two real feedback events in the whole database. The active model was
+#: trained on 972 such rows and reorders results at random; the heuristic it
+#: displaced was better.
+#:
+#: An earlier design proposed gating on ``len(set(labels)) <= 1``. That check PASSES
+#: here — three distinct values exist — and would train on a 2,675:1 imbalance
+#: while reporting success, which is worse than not training at all because it
+#: looks like progress. A count of informative labels is the honest gate.
+MIN_INFORMATIVE_LABELS = 50
+
+
+def _count_informative_labels(rows: list[dict]) -> int:
+    """Rows whose outcome says something other than "nothing happened".
+
+    A reward of exactly 0.5 is the neutral default the settlement path applies
+    when no outcome was reported, and ``None`` means the outcome column is
+    absent. Neither is evidence. Everything else is.
+    """
+    seen = 0
+    for row in rows:
+        reward = row.get("outcome_reward")
+        if reward is None:
+            continue
+        try:
+            value = float(reward)
+        except (TypeError, ValueError):
+            continue
+        if abs(value - 0.5) > 1e-9:
+            seen += 1
+    return seen
+
 def _run_shadow_cycle(
     *,
     memory_db_path: str,
@@ -137,6 +172,25 @@ def _run_shadow_cycle(
         out["aborted"] = "insufficient_data"
         return out
 
+    informative = _count_informative_labels(rows)
+    if informative < MIN_INFORMATIVE_LABELS:
+        # Honest refusal. See _count_informative_labels for why a row count is
+        # not a substitute for this, and why the answer must not be to lower
+        # the threshold until training starts.
+        logger.info(
+            "retrain skipped: %d informative label(s) of %d rows "
+            "(need %d). Rewards accumulate from reported outcomes; there is "
+            "nothing to learn from a corpus of one label.",
+            informative, len(rows), MIN_INFORMATIVE_LABELS,
+        )
+        out["aborted"] = "insufficient_label_signal"
+        out["metrics"] = {
+            "rows": len(rows),
+            "informative_labels": informative,
+            "required": MIN_INFORMATIVE_LABELS,
+        }
+        return out
+
     # Load prior active for in-sample shadow.
     try:
         from superlocalmemory.learning.database import LearningDatabase

package/src/superlocalmemory/learning/database.py

@@ -72,6 +72,10 @@ CREATE INDEX IF NOT EXISTS idx_engagement_profile_metric
 """
 
 
+
+from superlocalmemory.learning.signal_kinds import FEEDBACK_ONLY_SQL
+
+
 class LearningDatabase:
     """Persistent storage for the adaptive ranker's training pipeline.
 
@@ -182,7 +186,8 @@ class LearningDatabase:
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT COUNT(*) AS cnt FROM learning_signals WHERE profile_id = ?",
+                "SELECT COUNT(*) AS cnt FROM learning_signals "
+                f"WHERE profile_id = ?{FEEDBACK_ONLY_SQL}",
                 (profile_id,),
             ).fetchone()
             return int(row["cnt"]) if row else 0
@@ -364,15 +369,22 @@ class LearningDatabase:
     # ------------------------------------------------------------------
 
     def count_signals(self, profile_id: str) -> int:
-        """Count ``learning_signals`` rows for ``profile_id``.
+        """Count FEEDBACK rows in ``learning_signals`` for ``profile_id``.
 
         Used by ``_compute_ranker_phase`` + consolidation_worker training
         gate. Pure SELECT — thread-safe without lock.
+
+        Exposure rows are excluded. This counted every row until 4.1.0, which
+        on a live store meant 5,352 instead of 2 — a 2,675x inflation that
+        held the ranker in Phase 3 on two feedback events. See
+        ``learning/signal_kinds.py`` for why the predicate excludes exposures
+        rather than naming feedback kinds.
         """
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT COUNT(*) AS cnt FROM learning_signals WHERE profile_id = ?",
+                "SELECT COUNT(*) AS cnt FROM learning_signals "
+                f"WHERE profile_id = ?{FEEDBACK_ONLY_SQL}",
                 (profile_id,),
             ).fetchone()
             return int(row["cnt"]) if row else 0
@@ -608,6 +620,19 @@ class LearningDatabase:
                     "learning_features",
                     "learning_model_state",
                     "engagement_metrics",
+                    # bandit_plays holds shown_fact_ids — the identifiers of the
+                    # memories a person was actually shown — and bandit_arms is
+                    # a derived behavioural profile. Both are personal data and
+                    # neither was erased: this list was hardcoded, so
+                    # forget_profile() reported success and left a row reading
+                    # ["alice-private-memory-1", ...] in place. Reproduced
+                    # before fixing.
+                    #
+                    # The retention sweep is not a substitute. It deletes only
+                    # SETTLED plays older than the horizon, so an unsettled row
+                    # would have survived indefinitely.
+                    "bandit_plays",
+                    "bandit_arms",
                 ]
                 receipt_tables = {
                     row[0]
@@ -619,7 +644,17 @@ class LearningDatabase:
                 }
                 if profile_id is None:
                     tables.extend(sorted(receipt_tables))
+                present = {
+                    row[0] for row in conn.execute(
+                        "SELECT name FROM sqlite_master WHERE type='table'"
+                    )
+                }
                 for table in tables:
+                    # A store predating any of these tables must not abort the
+                    # erasure of the rest — an Article 17 request that fails
+                    # halfway is worse than one that skips an absent table.
+                    if table not in present:
+                        continue
                     if profile_id:
                         conn.execute(
                             f"DELETE FROM {table} WHERE profile_id = ?",
@@ -628,6 +663,28 @@ class LearningDatabase:
                     else:
                         conn.execute(f"DELETE FROM {table}")
                 conn.commit()
+                # The in-process ranking counter holds this profile's recent
+                # winners. Ephemeral, but an erasure must not leave them in a
+                # live process for the rest of its lifetime.
+                try:
+                    from superlocalmemory.learning.pcos import RECENT_TOPS
+
+                    RECENT_TOPS.forget(profile_id or "")
+                except Exception:  # pragma: no cover — advisory
+                    pass
+                # The per-session working set is this profile's data too.
+                # Cleared here as well as in the compliance path, because this
+                # is reached directly — by the transaction owners and by tests —
+                # and a residue left behind goes on biasing any later session
+                # that reuses one of the erased profile's session ids.
+                try:
+                    from superlocalmemory.core.working_memory import (
+                        discard_profile,
+                    )
+
+                    discard_profile(profile_id or "")
+                except Exception:  # pragma: no cover — never block an erasure
+                    pass
                 logger.info(
                     "Learning data reset%s",
                     f" for profile {profile_id}" if profile_id else " (all)",

package/src/superlocalmemory/learning/entity_compiler.py

@@ -170,23 +170,27 @@ class EntityCompiler:
         if not facts:
             return None
 
-        has_pagerank = any(f["pagerank_score"] is not None for f in facts)
-
-        # ── Phase 2: PageRank (short write, NO Ollama) ────────────────────────
-        if not has_pagerank and len(facts) > 2:
-            self._compute_pagerank([f["fact_id"] for f in facts], profile_id)
-            # Re-fetch with updated scores
-            with memory_read(self._db_path) as conn:
-                facts = conn.execute("""
-                    SELECT af.fact_id, af.content, af.confidence, af.created_at,
-                           fi.pagerank_score, fi.community_id
-                    FROM atomic_facts af
-                    LEFT JOIN fact_importance fi ON af.fact_id = fi.fact_id
-                    WHERE af.canonical_entities_json LIKE ? AND af.profile_id = ?
-                    ORDER BY fi.pagerank_score DESC NULLS LAST, af.confidence DESC
-                    LIMIT 50
-                """, (f"%{entity_id}%", profile_id)).fetchall()
-                facts = [dict(f) for f in facts]
+        # There was a second PageRank here, and it made recall worse.
+        #
+        # On finding no score for this entity's facts it built a COMPLETE graph
+        # over them -- every pair joined, weight 0.5 -- and ran PageRank on it.
+        # PageRank of K_n is uniformly 1/n, so every fact received the identical
+        # score and the re-fetch's ORDER BY fell straight through to confidence,
+        # which is what had ordered them in the first place. It bought nothing.
+        #
+        # What it cost: that 1/n landed in the same column the ranker reads as a
+        # whole-graph score. On the author's store, ten facts from one 10-fact
+        # cluster were written 0.1 each, against a real whole-graph maximum of
+        # 0.008744 and median of 0.000214 -- eleven times the largest true score
+        # and roughly 470x the median. The hop boost min(1 + pr*2, 2) gave them
+        # 1.2 where every real memory got 1.0004, and the ten of them together
+        # carried as much PageRank mass as the other 2,988 facts combined (the
+        # table summed to 1.9999 instead of 1). They were also written with no
+        # community, so the community bias could not see them either.
+        #
+        # Whole-graph metrics belong to core/graph_metrics, which owns this
+        # table. Ordering for compilation is confidence, as it always effectively
+        # was.
 
         # ── Phase 3: generate compiled truth — NO write lock held ────────────
         # Mode B calls Ollama (up to 30 s) — write lock MUST NOT be held here.
@@ -340,47 +344,6 @@ class EntityCompiler:
 
     # -- Helpers --
 
-    def _compute_pagerank(self, fact_ids: list[str], profile_id: str) -> None:
-        """Compute PageRank for a set of facts and store in fact_importance.
-
-        Concurrency fix (v3.8.4): uses memory_write() for the INSERT so the
-        process write lock is acquired and busy_timeout is set correctly.
-        Pure PageRank computation (networkx) happens BEFORE the write lock.
-        """
-        from superlocalmemory.storage.memory_write import memory_write
-
-        try:
-            import networkx as nx
-            G = nx.Graph()
-            for fid in fact_ids:
-                G.add_node(fid)
-            for i, fid1 in enumerate(fact_ids):
-                for fid2 in fact_ids[i + 1:]:
-                    G.add_edge(fid1, fid2, weight=0.5)
-
-            if len(G.nodes) < 2:
-                return
-
-            # Compute scores in pure Python — no lock held yet.
-            scores = nx.pagerank(G, alpha=0.85)
-            now = datetime.now(timezone.utc).isoformat()
-
-            # Short write: lock held only for the INSERT batch.
-            with memory_write(self._db_path) as conn:
-                for fid, score in scores.items():
-                    conn.execute("""
-                        INSERT INTO fact_importance
-                            (fact_id, profile_id, pagerank_score, computed_at)
-                        VALUES (?, ?, ?, ?)
-                        ON CONFLICT(fact_id) DO UPDATE
-                            SET pagerank_score = excluded.pagerank_score,
-                                computed_at    = excluded.computed_at
-                    """, (fid, profile_id, round(score, 6), now))
-        except ImportError:
-            logger.debug("NetworkX not available — skipping PageRank")
-        except Exception as exc:
-            logger.debug("PageRank computation failed: %s", exc)
-
     @staticmethod
     def _truncate(text: str, max_chars: int) -> str:
         """Truncate at sentence boundary within char limit."""

package/src/superlocalmemory/learning/feedback.py

@@ -49,6 +49,7 @@ from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
+from superlocalmemory.learning.signal_kinds import FEEDBACK_ONLY_SQL
 
 logger = logging.getLogger("superlocalmemory.learning.feedback")
 
@@ -572,7 +573,8 @@ class FeedbackCollector:
         conn = self._connect()
         try:
             row = conn.execute(
-                "SELECT COUNT(*) FROM learning_signals WHERE profile_id = ?",
+                "SELECT COUNT(*) FROM learning_signals "
+                f"WHERE profile_id = ?{FEEDBACK_ONLY_SQL}",
                 (profile_id,),
             ).fetchone()
             return row[0] if row else 0