superlocalmemory 3.6.14 → 3.6.16

package/src/superlocalmemory/core/recall_pipeline.py

@@ -587,9 +587,14 @@ def run_recall(
     access_log: Any = None,
     auto_linker: Any = None,
     fast: bool = False,
+    include_global: bool = False,
+    include_shared: bool = False,
 ) -> RecallResponse:
     """Recall relevant facts for a query.
 
+    Multi-scope: ``include_global`` / ``include_shared`` control which
+    scopes participate in retrieval (passed through to retrieval engine).
+
     Pipeline: retrieval -> agentic sufficiency (if configured) -> post-recall updates.
 
     V3.4.40: ``fast=True`` adds spreading_activation to the per-recall
@@ -623,6 +628,8 @@ def run_recall(
     response = retrieval_engine.recall(
         query, profile_id, m, limit,
         extra_disabled_channels=extra_disabled,
+        include_global=include_global,
+        include_shared=include_shared,
     )
     _mark("retrieval(chan+rerank)")
 

package/src/superlocalmemory/core/recall_worker.py

@@ -61,10 +61,15 @@ def _get_engine():
 
 def _handle_recall(
     query: str, limit: int, session_id: str = "", fast: bool = False,
+    include_global: bool | None = None, include_shared: bool | None = None,
 ) -> dict:
     engine = _get_engine()
+    # v3.6.15 multi-scope: None flags let engine.recall resolve the configured
+    # default (shared-off). The subprocess loads its own SLMConfig, so the
+    # resolution is identical to the in-process / daemon paths.
     response = engine.recall(
         query, limit=limit, session_id=session_id or None, fast=bool(fast),
+        include_global=include_global, include_shared=include_shared,
     )
 
     # Batch-fetch original memory text for all results
@@ -285,6 +290,8 @@ def _worker_main() -> None:
                 result = _handle_recall(
                     req.get("query", ""), req.get("limit", 10),
                     req.get("session_id", ""), bool(req.get("fast", False)),
+                    include_global=req.get("include_global"),
+                    include_shared=req.get("include_shared"),
                 )
                 _respond(result)
             elif cmd == "store":

package/src/superlocalmemory/core/store_pipeline.py

@@ -99,6 +99,17 @@ def enrich_fact(
         langevin_position=langevin_pos,
         emotional_valence=emotion.valence, emotional_arousal=emotion.arousal,
         signal_type=signal, created_at=fact.created_at,
+        pinned=getattr(fact, 'pinned', False),
+        # v3.6.15 multi-scope: scope is a per-MEMORY property — every fact
+        # derived from a memory inherits the memory's scope. The record is
+        # authoritative; fact-extractor output never carries scope, so reading
+        # it off the fact (as before) silently downgraded extracted facts to
+        # 'personal' and broke `--scope global` on the common extraction path.
+        scope=(getattr(record, 'scope', None)
+               or getattr(fact, 'scope', None) or 'personal'),
+        shared_with=(getattr(record, 'shared_with', None)
+                     if getattr(record, 'scope', None) in ('shared', 'global')
+                     else getattr(fact, 'shared_with', None)),
     )
 
 
@@ -146,6 +157,8 @@ def run_store(
     role: str = "user",
     metadata: dict[str, Any] | None = None,
     *,
+    scope: str = "personal",
+    shared_with: list[str] | None = None,
     config: SLMConfig,
     db: DatabaseManager,
     embedder: Any,
@@ -169,7 +182,11 @@ def run_store(
     context_generator: Any = None,
     consolidation_engine: Any = None,
 ) -> list[str]:
-    """Store content and extract structured facts. Returns fact_ids."""
+    """Store content and extract structured facts. Returns fact_ids.
+
+    Multi-scope: ``scope`` sets visibility (personal/shared/global).
+    ``shared_with`` is a list of profile_ids for shared scope.
+    """
     # Pre-operation hooks (trust gate, ABAC, rate limiter)
     hook_ctx = {
         "operation": "store",
@@ -203,6 +220,7 @@ def run_store(
         profile_id=profile_id, content=content,
         session_id=session_id, speaker=speaker, role=role,
         session_date=parsed_date, metadata=metadata or {},
+        scope=scope, shared_with=shared_with,
     )
     db.store_memory(record)
 
@@ -259,6 +277,8 @@ def run_store(
             observation_date=parsed_date,
             confidence=0.9,
             importance=0.5,
+            scope=scope,
+            shared_with=shared_with,
         )
         # Avoid duplicate if extraction already produced the exact same text
         extracted_texts = {f.content.strip().lower() for f in facts}
@@ -280,6 +300,8 @@ def run_store(
             observation_date=parsed_date,
             confidence=0.7,
             importance=0.3,
+            scope=scope,
+            shared_with=shared_with,
         )]
 
     if not facts:

package/src/superlocalmemory/core/worker_pool.py

@@ -68,6 +68,8 @@ class WorkerPool:
     def recall(
         self, query: str, limit: int = 10, session_id: str = "",
         fast: bool = False,
+        include_global: bool | None = None,
+        include_shared: bool | None = None,
     ) -> dict:
         """Run recall in worker subprocess. Returns result dict.
 
@@ -75,11 +77,21 @@ class WorkerPool:
         so the outcome-queue gets a pending_outcomes row for this
         recall. Without it, hook-based signals have no outcome to
         attach to.
+
+        v3.6.15 multi-scope: ``include_global``/``include_shared`` are forwarded
+        to the worker (and on to ``engine.recall``). ``None`` is sent verbatim
+        so the worker-side engine resolves the configured default — shared
+        memory is opt-in.
         """
-        return self._send({
+        msg = {
             "cmd": "recall", "query": query, "limit": limit,
             "session_id": session_id or "", "fast": bool(fast),
-        })
+        }
+        if include_global is not None:
+            msg["include_global"] = bool(include_global)
+        if include_shared is not None:
+            msg["include_shared"] = bool(include_shared)
+        return self._send(msg)
 
     def store(self, content: str, metadata: dict | None = None) -> dict:
         """Run store in worker subprocess. Returns result dict."""

package/src/superlocalmemory/hooks/session_registry.py

@@ -28,10 +28,14 @@ lost (reaper finalizes everything at neutral 0.5).
   MCP uses this as the default when the tool caller omits
   ``session_id``.
 
-Concurrency: one reader/writer lock (``fcntl.flock``) serialises
-updates. Rollover: entries older than 1 hour are pruned on every
-write. Fail-soft: every error path returns empty or the passed
-default — the learning loop must never crash the hot path.
+Concurrency: each write is atomic via write-temp + ``os.replace`` (atomic on
+POSIX/Windows), so a concurrent reader never sees a half-written file —
+last-writer-wins. This is best-effort, not lock-serialised: a concurrent
+read-modify-write may lose an interleaved update, which is acceptable because
+the registry only drives session attribution for closed-loop learning, not
+memory correctness. Rollover: entries older than 1 hour are pruned on every
+write. Fail-soft: every error path returns empty or the passed default — the
+learning loop must never crash the hot path.
 
 This is not a perfect correlation channel; two Claude sessions
 typing in the same second can race. For single-user workstations

package/src/superlocalmemory/mcp/_daemon_proxy.py

@@ -46,13 +46,23 @@ class DaemonPoolProxy:
     def recall(
         self, query: str, limit: int = 10, session_id: str = "",
         fast: bool = False,
+        include_global: bool | None = None,
+        include_shared: bool | None = None,
     ) -> dict[str, Any]:
-        params = urllib.parse.urlencode({
+        _params: dict[str, Any] = {
             "q": query,
             "limit": limit,
             "session_id": session_id or "",
             "fast": "true" if fast else "false",
-        })
+        }
+        # v3.6.15 multi-scope: only send the scope flags when explicitly set, so
+        # an unset value lets the daemon resolve the configured default (shared
+        # is opt-in). "None" must NOT become the string "none" on the wire.
+        if include_global is not None:
+            _params["include_global"] = "true" if include_global else "false"
+        if include_shared is not None:
+            _params["include_shared"] = "true" if include_shared else "false"
+        params = urllib.parse.urlencode(_params)
         try:
             with urllib.request.urlopen(
                 self._url(f"/recall?{params}"), timeout=self._timeout,

package/src/superlocalmemory/mcp/_pool_adapter.py

@@ -80,12 +80,21 @@ def pool_recall(query: str, limit: int = 10, **kwargs: Any) -> PoolRecallRespons
 
     Raises :class:`PoolError` on worker death or any non-ok envelope.
     """
-    raw = _pool().recall(
-        query=query,
-        limit=limit,
-        session_id=str(kwargs.get("session_id") or ""),
-        fast=bool(kwargs.get("fast", False)),
-    )
+    # v3.6.15 multi-scope: forward the scope-visibility flags when the caller
+    # set them. ``None`` (the default) is passed through so the daemon/engine
+    # resolves the configured default — shared memory is opt-in, so omitting
+    # them keeps recall scoped to this profile only.
+    _recall_kwargs: dict[str, Any] = {
+        "query": query,
+        "limit": limit,
+        "session_id": str(kwargs.get("session_id") or ""),
+        "fast": bool(kwargs.get("fast", False)),
+    }
+    if "include_global" in kwargs:
+        _recall_kwargs["include_global"] = kwargs["include_global"]
+    if "include_shared" in kwargs:
+        _recall_kwargs["include_shared"] = kwargs["include_shared"]
+    raw = _pool().recall(**_recall_kwargs)
     _unwrap_error(raw, "recall")
     items = raw.get("results", []) if isinstance(raw, dict) else []
     results = [

package/src/superlocalmemory/mcp/tools_core.py

@@ -106,11 +106,17 @@ def register_core_tools(server, get_engine: Callable) -> None:
         content: str, tags: str = "", project: str = "",
         importance: int = 5, session_id: str = "",
         agent_id: str = "mcp_client",
+        scope: str | None = None,
+        shared_with: str = "",
     ) -> dict:
         """Store content to memory with intelligent indexing.
 
         Extracts atomic facts, resolves entities, builds graph edges,
         and indexes for 4-channel retrieval.
+
+        Multi-scope: ``scope`` sets visibility (personal/shared/global).
+        ``shared_with`` is a comma-separated list of profile_ids for
+        shared scope.
         """
         # v3.6.10: resolve "mcp_client" sentinel → URL path (HTTP) or env var (stdio)
         if agent_id == "mcp_client":
@@ -122,6 +128,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
             "agent_id": agent_id,
             "session_id": session_id,
         }
+        # Parse shared_with from comma-separated string
+        _shared_list = [s.strip() for s in shared_with.split(",") if s.strip()] if shared_with else None
         # v3.5.5 WRITE-THROUGH: route through the daemon's /remember, which does
         # a synchronous verbatim insert (memory is keyword/BM25-recallable the
         # instant this returns) and enqueues async enrichment. This closes the
@@ -136,6 +144,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             if await _asyncio.to_thread(is_daemon_running):
                 resp = await _asyncio.to_thread(daemon_request, "POST", "/remember", {
                     "content": content, "tags": tags, "metadata": meta,
+                    "scope": scope, "shared_with": _shared_list,
                 })
                 if resp and (resp.get("fact_ids") is not None or resp.get("ok")):
                     fids = resp.get("fact_ids") or []
@@ -151,6 +160,13 @@ def register_core_tools(server, get_engine: Callable) -> None:
 
         try:
             from superlocalmemory.cli.pending_store import store_pending
+            # v3.6.15: preserve a non-personal scope through the offline path so
+            # the materializer replays the right visibility (else --scope global
+            # would silently downgrade to personal when the daemon is offline).
+            if scope and scope != "personal":
+                meta = {**meta, "scope": scope}
+                if _shared_list:
+                    meta["shared_with"] = _shared_list
             pending_id = store_pending(content, tags=tags, metadata=meta)
             return {
                 "success": True,
@@ -168,6 +184,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
     async def recall(
         query: str, limit: int = CANONICAL_RECALL_LIMIT, agent_id: str = "mcp_client",
         session_id: str = "", fast: bool = False,
+        include_global: bool | None = None,
+        include_shared: bool | None = None,
     ) -> dict:
         """Search memories by semantic query with 4-channel retrieval, RRF fusion, and reranking.
 
@@ -176,6 +194,11 @@ def register_core_tools(server, get_engine: Callable) -> None:
         engagement signals to this recall. Claude Code should pass its
         ``CLAUDE_SESSION_ID``. Omitting it degrades to "no closed-loop
         learning for this recall" — the recall itself always works.
+
+        Multi-scope: ``include_global`` / ``include_shared`` control which
+        scopes participate in retrieval. Leave them unset (``None``) to use the
+        configured default — shared memory is OPT-IN, so by default recall
+        returns only this profile's own facts. Pass ``True`` to opt in per call.
         """
         # v3.6.10: resolve "mcp_client" sentinel → URL path (HTTP) or env var (stdio)
         if agent_id == "mcp_client":
@@ -230,6 +253,8 @@ def register_core_tools(server, get_engine: Callable) -> None:
             result = await asyncio.to_thread(
                 pool.recall, query, limit=limit, session_id=effective_sid,
                 fast=bool(fast),
+                include_global=include_global,
+                include_shared=include_shared,
             )
             if result.get("ok"):
                 # Record implicit feedback: every returned result is a recall_hit

package/src/superlocalmemory/mcp/tools_v3.py

@@ -289,8 +289,13 @@ def register_v3_tools(server, get_engine: Callable) -> None:
             limit: Maximum results (default 10).
         """
         try:
+            import asyncio
             from superlocalmemory.mcp._daemon_proxy import choose_pool
-            raw = choose_pool().recall(query=query, limit=limit)
+            # choose_pool().recall uses blocking urllib; run off the event loop
+            # so recall_trace doesn't stall the MCP server for other tools.
+            raw = await asyncio.to_thread(
+                lambda: choose_pool().recall(query=query, limit=limit)
+            )
             items = raw.get("results", []) if isinstance(raw, dict) else []
             results = []
             for item in items[:limit]:

package/src/superlocalmemory/mcp/tools_v33.py

@@ -222,8 +222,10 @@ def register_v33_tools(server, get_engine: Callable) -> None:
             # v3.4.26: prefer the daemon's /consolidate/cognitive endpoint
             # so the heavy CognitiveConsolidator import stays out of the
             # MCP process. Fall back to local import only if no daemon.
-            daemon_result = _try_daemon_post(
-                "/consolidate/cognitive", {"profile_id": pid},
+            import asyncio
+            # blocking urllib (60s timeout) — keep it off the MCP event loop.
+            daemon_result = await asyncio.to_thread(
+                _try_daemon_post, "/consolidate/cognitive", {"profile_id": pid},
             )
             if daemon_result is not None:
                 _emit_event("ccq.consolidation_complete", {
@@ -434,8 +436,10 @@ def register_v33_tools(server, get_engine: Callable) -> None:
             # v3.4.26: prefer the daemon so ForgettingScheduler /
             # ConsolidationWorker / EbbinghausCurve don't load inside
             # the MCP process.
-            daemon_result = _try_daemon_post(
-                "/maintenance/run", {"profile_id": pid},
+            import asyncio
+            # blocking urllib — keep it off the MCP event loop.
+            daemon_result = await asyncio.to_thread(
+                _try_daemon_post, "/maintenance/run", {"profile_id": pid},
             )
             if daemon_result is not None:
                 daemon_result.setdefault("success", True)

package/src/superlocalmemory/retrieval/bm25_channel.py

@@ -86,9 +86,15 @@ class BM25Channel:
             return
 
         token_map = self._db.get_all_bm25_tokens(profile_id)
+        _inc_global = getattr(self, 'include_global', False)
+        _inc_shared = getattr(self, 'include_shared', False)
         if not token_map:
             # Fallback: tokenize facts directly if no pre-stored tokens
-            facts = self._db.get_all_facts(profile_id)
+            facts = self._db.get_all_facts(
+                profile_id,
+                include_global=_inc_global,
+                include_shared=_inc_shared,
+            )
             for fact in facts:
                 if fact.fact_id in self._fact_id_set:
                     continue
@@ -104,7 +110,11 @@ class BM25Channel:
             # Load raw texts for phrase matching (V3.3.12)
             fact_content_map = {}
             try:
-                facts = self._db.get_all_facts(profile_id)
+                facts = self._db.get_all_facts(
+                    profile_id,
+                    include_global=_inc_global,
+                    include_shared=_inc_shared,
+                )
                 fact_content_map = {f.fact_id: f.content for f in facts}
             except Exception:
                 pass

package/src/superlocalmemory/retrieval/engine.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import logging
 import math
 import re
+import threading
 import time
 from typing import TYPE_CHECKING, Any, Protocol
 
@@ -84,6 +85,12 @@ class RetrievalEngine:
         self._profile_channel = profile_channel
         self._bridge = bridge_discovery
         self._trust_scorer = trust_scorer
+        # v3.6.15: serialise the per-recall scope-flag set + channel execution.
+        # Channel instances are SHARED across concurrent recalls (the daemon runs
+        # several in parallel); without this, recall B's flags could overwrite
+        # recall A's mid-flight on the shared channels. Uncontended for a single
+        # recall (~0 cost); only the channel phase of concurrent recalls serialises.
+        self._scope_lock = threading.Lock()
 
         # V3.3.4: LRU cache for query embeddings (avoids redundant Ollama API calls)
         # V3.4.40 (2026-05-09): bumped 64 -> 512. Each cached embedding is ~3KB
@@ -117,9 +124,15 @@ class RetrievalEngine:
         mode: Mode = Mode.A, limit: int = 20,
         *,
         extra_disabled_channels: set[str] | None = None,
+        include_global: bool = True,
+        include_shared: bool = True,
     ) -> RecallResponse:
         """Full retrieval pipeline: strategy -> channels -> RRF -> rerank.
 
+        Multi-scope: ``include_global`` / ``include_shared`` control which
+        scopes participate in retrieval. Both default to True for backward
+        compatibility (existing data has scope='personal' — no effect).
+
         V3.4.40 (2026-05-09): ``extra_disabled_channels`` allows callers to
         skip specific channels for a single recall (e.g. SpreadingActivation
         for the ``--fast`` CLI flag) without mutating shared config.
@@ -127,6 +140,12 @@ class RetrievalEngine:
         t0 = time.monotonic()
         self._extra_disabled = set(extra_disabled_channels or ())
 
+        # Multi-scope: scope flags are set on the (shared) channel instances +
+        # the channels executed atomically under self._scope_lock — see the
+        # `# 3. Run channels` block below. (profile_channel does not read scope.)
+        self._include_global = include_global
+        self._include_shared = include_shared
+
         # v3.5.0 diagnostic: stage timing inside retrieval (SLM_RECALL_TIMING=1).
         import os as _os_e
         import time as _time_e
@@ -159,8 +178,18 @@ class RetrievalEngine:
         # Dynamic top-k for aggregation queries
         effective_limit = 100 if strat.query_type == "aggregation" else limit
 
-        # 3. Run 4 channels
-        ch_results = self._run_channels(query, profile_id, strat)
+        # 3. Run channels. Set the scope flags on the shared channel instances
+        # and execute them under self._scope_lock so a concurrent recall can't
+        # interleave its scope visibility onto these channels mid-flight. The
+        # worker threads spawned inside _run_channels are joined before the lock
+        # releases, so every channel read sees THIS recall's flags.
+        with self._scope_lock:
+            for ch in (self._semantic, self._bm25, self._entity, self._temporal,
+                       self._hopfield, self._spreading_activation):
+                if ch is not None:
+                    ch.include_global = include_global
+                    ch.include_shared = include_shared
+            ch_results = self._run_channels(query, profile_id, strat)
         _em("run_channels")
         if profile_hits:
             ch_results["profile"] = profile_hits
@@ -657,7 +686,11 @@ class RetrievalEngine:
         needed = [fr.fact_id for fr in fused]
         if not needed:
             return {}
-        facts = self._db.get_facts_by_ids(needed, profile_id)
+        facts = self._db.get_facts_by_ids(
+            needed, profile_id,
+            include_global=getattr(self, '_include_global', True),
+            include_shared=getattr(self, '_include_shared', True),
+        )
         return {f.fact_id: f for f in facts}
 
     # -- Cross-encoder rerank -----------------------------------------------

package/src/superlocalmemory/retrieval/entity_channel.py

@@ -283,7 +283,7 @@ class EntityGraphChannel:
                 for fid in self._entity_to_facts.get(eid, ()):
                     activation[fid] = max(activation[fid], 1.0)
             else:
-                for fact in self._db.get_facts_by_entity(eid, profile_id):
+                for fact in self._db.get_facts_by_entity(eid, profile_id, include_global=getattr(self, 'include_global', False), include_shared=getattr(self, 'include_shared', False)):
                     activation[fact.fact_id] = max(activation[fact.fact_id], 1.0)
 
         # Spreading activation through graph edges (all in-memory O(1) lookups)
@@ -317,7 +317,7 @@ class EntityGraphChannel:
                     # NOTE: SQL fallback path does NOT use graph intelligence (P1/P2/P3).
                     # Graph intelligence is only available on the in-memory cache path.
                     # This fallback exists for mock/test DBs. See Phase 7 LLD H-01.
-                    for edge in self._db.get_edges_for_node(fid, profile_id):
+                    for edge in self._db.get_edges_for_node(fid, profile_id, include_global=getattr(self, 'include_global', False), include_shared=getattr(self, 'include_shared', False)):
                         neighbor = edge.target_id if edge.source_id == fid else edge.source_id
                         propagated = activation[fid] * self._decay
                         if propagated >= self._threshold and propagated > activation.get(neighbor, 0.0):
@@ -342,7 +342,7 @@ class EntityGraphChannel:
                 new_eids_sql = self._discover_entities(frontier, profile_id, visited_entities)
                 for eid in new_eids_sql:
                     visited_entities.add(eid)
-                    for fact in self._db.get_facts_by_entity(eid, profile_id):
+                    for fact in self._db.get_facts_by_entity(eid, profile_id, include_global=getattr(self, 'include_global', False), include_shared=getattr(self, 'include_shared', False)):
                         if hop_decay > activation.get(fact.fact_id, 0.0):
                             activation[fact.fact_id] = hop_decay
                             next_frontier.add(fact.fact_id)
@@ -438,7 +438,7 @@ class EntityGraphChannel:
                 for fid in self._entity_to_facts.get(eid, ()):
                     activation[fid] = max(activation[fid], 1.0)
             else:
-                for fact in self._db.get_facts_by_entity(eid, profile_id):
+                for fact in self._db.get_facts_by_entity(eid, profile_id, include_global=getattr(self, 'include_global', False), include_shared=getattr(self, 'include_shared', False)):
                     activation[fact.fact_id] = max(activation[fact.fact_id], 1.0)
 
         frontier = set(activation.keys())
@@ -628,7 +628,7 @@ class EntityGraphChannel:
             # Map entity scores to fact scores
             fact_scores: list[tuple[str, float]] = []
             for entity_id, score in scored:
-                facts = self._db.get_facts_by_entity(entity_id, profile_id)
+                facts = self._db.get_facts_by_entity(entity_id, profile_id, include_global=getattr(self, 'include_global', False), include_shared=getattr(self, 'include_shared', False))
                 for fact in facts:
                     fact_scores.append((fact.fact_id, score))
 

package/src/superlocalmemory/retrieval/hopfield_channel.py

@@ -248,7 +248,11 @@ class HopfieldChannel:
 
         # Stage 2: Load candidate facts
         candidate_ids = [fid for fid, _ in knn_results]
-        candidates = self._db.get_facts_by_ids(candidate_ids, profile_id)
+        candidates = self._db.get_facts_by_ids(
+            candidate_ids, profile_id,
+            include_global=getattr(self, 'include_global', False),
+            include_shared=getattr(self, 'include_shared', False),
+        )
         if not candidates:
             return []
 
@@ -304,7 +308,11 @@ class HopfieldChannel:
         # Step 2: Load facts (V3.3.12: cap to most recent 5000 to bound memory)
         # memory-bounding-02: push the cap into SQL (LIMIT) so we don't
         # deserialize the whole table just to slice it.
-        facts = self._db.get_all_facts(profile_id, limit=5000)
+        facts = self._db.get_all_facts(
+            profile_id, limit=5000,
+            include_global=getattr(self, 'include_global', False),
+            include_shared=getattr(self, 'include_shared', False),
+        )
         if not facts:
             return (None, [])
 

package/src/superlocalmemory/retrieval/semantic_channel.py

@@ -168,7 +168,11 @@ class SemanticChannel:
         # Step 2: Load only the candidate facts (NOT all facts)
         candidate_ids = [fid for fid, _ in knn_results]
         knn_scores = {fid: score for fid, score in knn_results}
-        facts = self._db.get_facts_by_ids(candidate_ids, profile_id)
+        facts = self._db.get_facts_by_ids(
+            candidate_ids, profile_id,
+            include_global=getattr(self, 'include_global', False),
+            include_shared=getattr(self, 'include_shared', False),
+        )
 
         if not facts:
             return [(fid, score) for fid, score in knn_results[:top_k]]
@@ -230,7 +234,11 @@ class SemanticChannel:
             q_mean = np.array(qm, dtype=np.float32)
             q_var = np.array(qv, dtype=np.float32)
 
-        facts = self._db.get_all_facts(profile_id)
+        facts = self._db.get_all_facts(
+            profile_id,
+            include_global=getattr(self, 'include_global', False),
+            include_shared=getattr(self, 'include_shared', False),
+        )
 
         scored: list[tuple[str, float]] = []
         for fact in facts: