superlocalmemory 4.0.7 → 4.0.9

package/src/superlocalmemory/core/engine.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import logging
 import os
 import threading
+import time
 from pathlib import Path
 from typing import Any
 
@@ -49,7 +50,7 @@ def _verify_ingestion_schema(memory_db: Path) -> bool:
 
 
 # ---------------------------------------------------------------------------
-# Workstream D (3.8.4) — warm-guard sync embed helpers
+# Embedding a memory on the write path, before the receipt is returned
 # ---------------------------------------------------------------------------
 
 def _is_remote_embedder(embedder: object) -> bool:
@@ -132,11 +133,18 @@ class MemoryEngine:
         self._consolidation_engine = None
         self._maintenance_scheduler = None
         self._hooks = HookRegistry()
-        # Workstream D (3.8.4): single-worker pool reused across store_fast() calls.
-        # Lazy-created on first warm-guard attempt; avoids per-call thread churn.
+        # One single-worker pool reused across store_fast() calls, created on the
+        # first warm-guard attempt. Reusing it avoids a thread per call.
         self._store_fast_embed_pool: object | None = None
-        # Lock guards the lazy-init to prevent TOCTOU race on concurrent first calls.
+        # Guards the lazy creation so concurrent first calls cannot each build one.
         self._store_fast_embed_pool_lock = threading.Lock()
+        # Set once the engine is closed, and never cleared. A caller already
+        # inside the warm-guard path when close() runs will reach the creation
+        # check afterwards and find None; without this it would build a
+        # replacement pool that nothing owns and nothing will shut down, so a
+        # burst of writes arriving during shutdown leaks a thread each and holds
+        # the process open past its shutdown budget.
+        self._store_fast_embed_pool_closed = False
 
     # -- Public properties (Phase 2+ access) --------------------------------
 
@@ -535,6 +543,348 @@ class MemoryEngine:
             trusted_actor_id=local_trusted_actor_id("python-api-prebuilt"),
         )
 
+    def _warm_guard_embed(
+        self, text: str, *, timeout_s: float | None = None,
+    ) -> tuple[list[float] | None, Any, Any]:
+        """Embed now if it is cheap and safe to, otherwise leave it to the materializer.
+
+        A fact with no vector is invisible to the semantic channel, so a memory
+        written moments ago is the hardest thing in the store to find. Computing
+        it inline closes that window — but only when doing so cannot hurt anyone
+        else, because this daemon serves many sessions at once.
+
+        Four constraints, each load-bearing:
+
+        * only when the embedder is provably warm and local, so a cold start or a
+          network round-trip can never be paid on a write;
+        * on one shared single-worker pool, so N concurrent writers cannot spawn
+          N threads — the sixth caller simply misses its deadline and defers;
+        * inside ``background_work()``, so a foreground recall preempts it rather
+          than queueing behind it;
+        * behind a hard deadline, after which the caller proceeds with no
+          embedding and the background materializer finishes the job.
+
+        Returns ``(embedding, fisher_mean, fisher_variance)``, any of which may be
+        ``None``. Never raises: every failure means "not now", not "write failed".
+        """
+        emb = None
+        fmean = fvar = None
+        _embedder_ref = self._embedder
+        if (
+            _embedder_ref is None
+            or getattr(_embedder_ref, "_available", None) is not True
+            or _is_remote_embedder(_embedder_ref)
+        ):
+            return None, None, None
+
+        import concurrent.futures as _cf
+
+        # Lazy-init once per engine — avoids per-call thread churn. Double-checked
+        # locking guards against TOCTOU on concurrent first calls.
+        if self._store_fast_embed_pool is None:
+            with self._store_fast_embed_pool_lock:
+                if self._store_fast_embed_pool_closed:
+                    # Shutdown happened while this call was between the check
+                    # above and this lock. Decline rather than resurrect the
+                    # pool: the fact is already committed durably and keeps its
+                    # place in the background queue.
+                    return None, None, None
+                if self._store_fast_embed_pool is None:
+                    self._store_fast_embed_pool = _cf.ThreadPoolExecutor(
+                        max_workers=1,
+                        thread_name_prefix="slm-sg-embed",
+                    )
+        # A ceiling, not a target. Storing a memory is allowed up to 1.5 s in
+        # total, and giving up on the embedding early is not free: it is the
+        # difference between a memory that can be found by asking a question and
+        # one that can only be found by quoting its own words. Within the budget
+        # the more complete outcome wins, so this waits a full second rather than
+        # half of one. Both values below are milliseconds via the environment.
+        if timeout_s is None:
+            try:
+                timeout_s = int(os.environ.get("SLM_STORE_FAST_EMBED_TIMEOUT_MS", 1000)) / 1000.0
+            except (ValueError, TypeError):
+                timeout_s = 1.0
+        try:
+            def _best_effort_embed():
+                from superlocalmemory.core.recall_gate import background_work
+                with background_work():
+                    return _embedder_ref.embed(text)
+
+            _future = self._store_fast_embed_pool.submit(_best_effort_embed)
+            try:
+                emb = _future.result(timeout=timeout_s)
+                if emb:
+                    fmean, fvar = _embedder_ref.compute_fisher_params(emb)
+            except _cf.TimeoutError:
+                # Cancel rather than abandon. This pool has a single worker, so a
+                # task left running holds it for every caller behind us: each in
+                # turn times out and queues another task that runs after its
+                # caller has already answered. Cancel only stops it if it has not
+                # started, which is exactly the queued backlog we care about.
+                _future.cancel()
+                logger.debug(
+                    "warm-guard embed timed out (>%.0fms) — deferring to materializer",
+                    timeout_s * 1000,
+                )
+                emb = None
+            except Exception as _exc:
+                logger.debug("warm-guard embed failed (%s) — deferring to materializer", _exc)
+                emb = None
+        except Exception as _exc:
+            logger.debug("warm-guard pool submit failed (%s)", _exc)
+            emb = None
+        return emb, fmean, fvar
+
+    def _projection_has(self, fact_id: str) -> bool:
+        """Can the meaning-based channel reach this fact?
+
+        Answered by the vector store, which owns the question, and never from
+        ``atomic_facts.embedding``. The column and the projection can disagree,
+        and when they do it is the projection that decides whether a search
+        finds the fact. Reachability also needs more than a stored vector: the
+        search joins two projection tables, so a vector present in one of them
+        and absent from the other is not reachable. That predicate belongs to
+        the store; duplicating it here is how the column and the projection
+        drifted apart in the first place.
+
+        Fails closed. A store that cannot answer is treated as "not reachable",
+        which costs at most one redundant idempotent write and can never report
+        a fact as findable when it is not.
+        """
+        store = getattr(self, "_vector_store", None)
+        answer = getattr(store, "is_searchable_by_meaning", None) if store else None
+        if not callable(answer):
+            return False
+        try:
+            return bool(answer(fact_id, self._profile_id))
+        except Exception:
+            return False
+
+    def _attach_vector(
+        self, fact_id: str, emb: list[float],
+        fmean: float | None, fvar: float | None,
+    ) -> bool:
+        """Attach a vector to a stored fact. True only if a search can now find it.
+
+        Two representations are involved and they answer different questions. The
+        vector projection is what a search on meaning queries, so it decides
+        whether the fact is *findable*. The ``atomic_facts.embedding`` column is
+        where the vector *lives* — it is what an export, a backup or a direct
+        fetch reads, and what a re-projection would be rebuilt from.
+
+        So:
+
+        * **The projection is attempted first**, because that is the ordering that
+          keeps the two consistent when both can succeed.
+        * **The column is written either way.** The vector has already been
+          computed and it is real data; withholding it because the projection was
+          refused would discard it and leave the repair pass paying for the model
+          again on every pass. Every reason a projection is refused — no search
+          extension on this platform, a dimension change, a store at a different
+          dimension — is a property of the installation and not of this fact, so
+          withholding one fact's column repairs nothing.
+        * **The return value is the honest answer to "can this be found by
+          meaning", and it is False whenever the projection did not accept the
+          vector.** That is what keeps a receipt from claiming a memory is
+          searchable when no search can reach it, which was the actual harm in
+          writing these two out of order — not the column itself.
+        * **If the projection succeeded and the column write then failed, the
+          projection is rolled back.** Otherwise a search finds a fact whose
+          vector nothing else can see, and nothing would ever reconcile them.
+
+        Never raises. The durable write has already happened before this runs; a
+        fact that is not projected keeps its place in the background queue.
+
+        Once started, the pair runs to completion and is not interrupted by a
+        caller deadline. Abandoning it half-way is what produces the disagreeing
+        states above, so a deadline can decide whether to *begin* the pair, never
+        whether to finish it. Callers check their budget immediately before
+        calling. Bounding the pair itself is a property of the write lock.
+        """
+        projected = False
+        store = getattr(self, "_vector_store", None)
+        if store is not None and getattr(store, "available", False):
+            try:
+                projected = bool(store.upsert(fact_id, self._profile_id, emb))
+                if not projected:
+                    logger.warning(
+                        "vector projection refused for %s — stored but not "
+                        "findable by meaning", fact_id[:12],
+                    )
+            except Exception as exc:
+                logger.warning(
+                    "vector projection failed for %s (%s: %s) — stored but not "
+                    "findable by meaning",
+                    fact_id[:12], type(exc).__name__, exc,
+                )
+            if projected:
+                index = getattr(self, "_ann_index", None)
+                if index is not None:
+                    try:
+                        index.add(fact_id, emb)
+                    except Exception:
+                        logger.warning(
+                            "in-memory index rejected %s", fact_id[:12],
+                            exc_info=True,
+                        )
+
+        if not self._write_canonical_vector(fact_id, emb, fmean, fvar):
+            if projected:
+                logger.warning(
+                    "canonical vector write failed for %s — undoing the "
+                    "projection so the two representations cannot disagree",
+                    fact_id[:12],
+                )
+                self._detach_vector(fact_id)
+            return False
+        return projected
+
+    def _write_canonical_vector(
+        self, fact_id: str, emb: list[float],
+        fmean: float | None, fvar: float | None,
+    ) -> bool:
+        """Write the vector to ``atomic_facts``. False if it did not land."""
+        try:
+            self._db.update_fact(
+                fact_id,
+                {"embedding": emb, "fisher_mean": fmean, "fisher_variance": fvar},
+                profile_id=self._profile_id,
+            )
+            return True
+        except Exception as exc:
+            logger.warning(
+                "canonical vector write failed for %s (%s: %s)",
+                fact_id[:12], type(exc).__name__, exc,
+            )
+            return False
+
+    def _detach_vector(self, fact_id: str) -> None:
+        """Undo a projection whose canonical write did not land.
+
+        Returns the row to the one state that heals itself: no vector anywhere,
+        which is what the repair pass looks for.
+        """
+        store = getattr(self, "_vector_store", None)
+        delete = getattr(store, "delete", None) if store else None
+        if callable(delete):
+            try:
+                delete(fact_id)
+            except Exception:
+                logger.warning(
+                    "could not undo the projection for %s; it and the canonical "
+                    "column now disagree", fact_id[:12], exc_info=True,
+                )
+        index = getattr(self, "_ann_index", None)
+        remove = getattr(index, "remove", None) if index else None
+        if callable(remove):
+            try:
+                remove(fact_id)
+            except Exception:
+                logger.warning(
+                    "could not undo the index entry for %s", fact_id[:12],
+                    exc_info=True,
+                )
+
+    def enrich_new_facts_now(
+        self, fact_ids: list[str], *, timeout_s: float | None = None,
+    ) -> int:
+        """Make just-written facts searchable by meaning, within a deadline.
+
+        Returns how many of ``fact_ids`` ARE searchable by meaning when this
+        returns — not how many were embedded here. A fact that already had a
+        vector counts, because the caller uses this number to tell the user
+        whether their memory can be found, and "not embedded by me" is not the
+        same statement as "not findable".
+
+        Every write path in the product — the command line, the tool interface and
+        the dashboard — commits through one durable receipt and then relies on a
+        background pass for enrichment. Until that pass runs, the memory can only
+        be found by quoting its own wording, which is not how anyone asks. This
+        closes that window for whichever facts it can reach in time, and reports
+        honestly how many it reached.
+
+        The durable write has already happened before this is called. Nothing here
+        can fail it: on any error or timeout the fact simply keeps its place in the
+        background queue.
+        """
+        if not fact_ids:
+            return 0
+        # Components are built on demand. Without this the embedder is still
+        # None and every fact is silently skipped as "nothing to do" — which
+        # looks exactly like "there was nothing to enrich".
+        self._require_full("enrich_new_facts_now")
+        self._ensure_init()
+        # Matches the default the write path uses for its own embedding attempt;
+        # the two were allowed to drift apart, so a direct caller got half the
+        # budget the daemon gives.
+        deadline = time.monotonic() + (timeout_s if timeout_s is not None else 1.0)
+        enriched = 0
+        for fact_id in fact_ids:
+            try:
+                fact = self._db.get_fact(fact_id, self._profile_id)
+                if fact is None:
+                    continue
+                already = self._projection_has(fact_id)
+                if already and getattr(fact, "embedding", None):
+                    # Findable by meaning, and the two representations agree.
+                    # Counting it keeps the caller's receipt truthful: saying
+                    # "wording only" about a fact that is already fully
+                    # searchable is its own kind of wrong.
+                    #
+                    # BOTH are required. A projection with no canonical vector is
+                    # a fact a search can return while an export, a backup or a
+                    # direct fetch sees nothing — and treating the projection
+                    # alone as proof of health means no pass ever repairs it. A
+                    # canonical vector with no projection is the opposite, and
+                    # equally unrepaired. Requiring agreement is what makes both
+                    # states heal instead of persisting silently.
+                    enriched += 1
+                    continue
+                # Answering "is it already findable" costs one indexed lookup and
+                # no model call, so it is done BEFORE the budget check: a caller
+                # that is out of time still deserves an honest answer about a
+                # fact that needs no work. Only the work below needs a budget.
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    break
+                # Re-checked immediately before the writes below as well. The
+                # caller awaits this on a thread and stops waiting at its own
+                # deadline, but the thread keeps running — so a late write could
+                # land while the next request already holds the write lock. Past
+                # the deadline this stops writing rather than racing a
+                # transaction nobody is waiting for.
+                emb = getattr(fact, "embedding", None)
+                fmean = getattr(fact, "fisher_mean", None)
+                fvar = getattr(fact, "fisher_variance", None)
+                if not emb:
+                    emb, fmean, fvar = self._warm_guard_embed(
+                        fact.content, timeout_s=remaining,
+                    )
+                    if not emb:
+                        continue
+                    if time.monotonic() >= deadline:
+                        # The embed itself consumed the budget; the caller has
+                        # moved on. Leave this fact to the background pass.
+                        break
+                # The row already holds a vector that never reached the
+                # projection: reuse it rather than paying for the model again.
+                if time.monotonic() >= deadline:
+                    # Checked here as well as after the embed, because reusing a
+                    # vector already on the row skips that check entirely and the
+                    # fetch above can itself be slow under write contention.
+                    break
+                if self._attach_vector(fact_id, emb, fmean, fvar):
+                    enriched += 1
+            except Exception as exc:
+                # Warning, not debug. A run that enriches nothing returns 0 in a
+                # millisecond and reads exactly like "there was nothing to do".
+                logger.warning(
+                    "inline enrichment failed for %s (%s: %s) — left for the "
+                    "background pass", fact_id[:12], type(exc).__name__, exc,
+                )
+        return enriched
+
     def store_fast(
         self, content: str, metadata: dict[str, Any] | None = None,
         *, scope: str = "personal", shared_with: list[str] | None = None,
@@ -612,78 +962,31 @@ class MemoryEngine:
         #
         # 3.8.4 extension: when the embedder is PROVABLY warm (_available is True)
         # AND is a local embedder (not a remote cloud/OpenAI endpoint), compute the
-        # embedding synchronously with a hard 500ms cap. On timeout or any
+        # embedding synchronously with a hard 1s cap. On timeout or any
         # exception, fall through to emb=None — the materializer fills it async.
         # This preserves the 3.8.2 invariant for cold start while eliminating the
         # semantic-channel blind spot on warm daemons (the top UX complaint).
-        emb = None
-        fmean = fvar = None
-        _embedder_ref = self._embedder
-        if (
-            _embedder_ref is not None
-            and getattr(_embedder_ref, "_available", None) is True
-            and not _is_remote_embedder(_embedder_ref)
-        ):
-            import concurrent.futures as _cf
-            # Lazy-init the pool once per engine instance — avoids per-call
-            # thread churn and the associated resource leak from discard-on-exit.
-            # Double-checked locking guards against TOCTOU on concurrent first calls.
-            if self._store_fast_embed_pool is None:
-                with self._store_fast_embed_pool_lock:
-                    if self._store_fast_embed_pool is None:
-                        self._store_fast_embed_pool = _cf.ThreadPoolExecutor(
-                            max_workers=1,
-                            thread_name_prefix="slm-sg-embed",
-                        )
-            try:
-                _timeout_s = int(os.environ.get("SLM_STORE_FAST_EMBED_TIMEOUT_MS", 500)) / 1000.0
-            except (ValueError, TypeError):
-                _timeout_s = 0.5  # default 500 ms
-            try:
-                def _best_effort_embed():
-                    from superlocalmemory.core.recall_gate import background_work
-                    with background_work():
-                        return _embedder_ref.embed(fact_text)
-
-                _future = self._store_fast_embed_pool.submit(_best_effort_embed)
-                try:
-                    emb = _future.result(timeout=_timeout_s)
-                    if emb:
-                        fmean, fvar = _embedder_ref.compute_fisher_params(emb)
-                except _cf.TimeoutError:
-                    logger.debug(
-                        "store_fast: warm-guard embed timed out (>%.0fms) — deferring to materializer",
-                        _timeout_s * 1000,
-                    )
-                    emb = None
-                except Exception as _exc:
-                    logger.debug(
-                        "store_fast: warm-guard embed failed (%s) — deferring to materializer",
-                        _exc,
-                    )
-                    emb = None
-            except Exception as _exc:
-                logger.debug("store_fast: warm-guard pool submit failed (%s)", _exc)
-                emb = None
+        emb, fmean, fvar = self._warm_guard_embed(fact_text)
         fact = AtomicFact(
             fact_id=_uuid.uuid4().hex[:16], memory_id=record.memory_id,
             profile_id=self._profile_id, content=fact_text,
             fact_type=FactType.EPISODIC, entities=ents,
             observation_date=session_date or now[:10],
             confidence=0.7, importance=0.5,
-            embedding=emb, fisher_mean=fmean, fisher_variance=fvar,
+            # The vector is attached after this row exists, not with it. The
+            # projection that the meaning-based channel searches has a foreign
+            # key onto this row, so it cannot be written first; and writing this
+            # column first would hide the fact from the repair pass if the
+            # projection then failed. _attach_vector owns that ordering.
+            embedding=None, fisher_mean=None, fisher_variance=None,
             created_at=now,
             scope=scope, shared_with=shared_with,
         )
         self._db.store_fact(fact)  # FTS5 trigger → immediately BM25-recallable
-        # Upsert to vector store so the semantic channel finds it now.
-        if index_external:
-            try:
-                vs = getattr(self, "_vector_store", None)
-                if emb and vs and getattr(vs, "available", False):
-                    vs.upsert(fact.fact_id, self._profile_id, emb)
-            except Exception:
-                pass
+        # Attach the vector so the meaning-based channel finds it now, through
+        # the same ordering every other write path uses.
+        if emb and index_external:
+            self._attach_vector(fact.fact_id, emb, fmean, fvar)
         # Persist BM25 tokens too (covers the in-memory rank_bm25 fallback path).
         if index_external:
             try:
@@ -828,8 +1131,13 @@ class MemoryEngine:
         embed_pool_lock = getattr(self, "_store_fast_embed_pool_lock", None)
         if embed_pool_lock is not None:
             with embed_pool_lock:
+                # Marked closed under the same lock that guards creation, so a
+                # call already past the unlocked check declines instead of
+                # building an unowned replacement.
+                self._store_fast_embed_pool_closed = True
                 embed_pool, self._store_fast_embed_pool = self._store_fast_embed_pool, None
         else:
+            self._store_fast_embed_pool_closed = True
             self._store_fast_embed_pool = None
         if embed_pool is not None:
             try:

package/src/superlocalmemory/core/evidence_bundle.py

@@ -12,6 +12,8 @@ from __future__ import annotations
 
 import hashlib
 import json
+
+from superlocalmemory.storage.embedding_codec import encode_embedding
 import re
 from dataclasses import dataclass
 from pathlib import Path
@@ -435,7 +437,7 @@ def rebuild_derived_state(
                 vector = embedder.embed(str(fact["content"]))
                 db.execute(
                     "UPDATE atomic_facts SET embedding=? WHERE fact_id=? AND profile_id=?",
-                    (json.dumps(vector, separators=(",", ":")), fact["fact_id"], profile_id),
+                    (encode_embedding(vector), fact["fact_id"], profile_id),
                 )
                 embeddings += 1
     return {"bm25_rows": bm25_rows, "embeddings": embeddings}

package/src/superlocalmemory/core/install_detector.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""Detect all SuperLocalMemory installations present on this machine.
+
+Supports three install types: pipx, venv (~/.slm-venv), and npm global.
+All detection is read-only and fast (< 200 ms). No writes are ever performed.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Roots for the two Python install types. Patched in tests.
+_VENV_ROOT: Path = Path.home() / ".slm-venv"
+_PIPX_ROOT: Path = Path.home() / ".local" / "pipx" / "venvs" / "superlocalmemory"
+
+
+def _npm_global_root() -> Optional[Path]:
+    """Return the npm global node_modules root, or None on any failure."""
+    try:
+        result = subprocess.run(
+            ["npm", "root", "-g"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode == 0:
+            root = result.stdout.strip()
+            if root:
+                return Path(root)
+    except Exception:  # npm absent, timeout, etc.
+        pass
+    return None
+
+
+def _read_python_version(base: Path) -> Optional[str]:
+    """Read __version__ from the first matching site-packages layout under base.
+
+    Both layouts are searched. POSIX virtualenvs use
+    ``lib/python3.13/site-packages``; Windows uses ``Lib/site-packages`` with no
+    version component and a capitalised directory. Searching only the POSIX
+    shape made detection silently return None on Windows — which is precisely
+    where multi-install divergence between pip and npm is most likely, and where
+    the version-mismatch error would then name no installations at all.
+    """
+    patterns = [
+        str(base / "lib" / "python*" / "site-packages" / "superlocalmemory" / "__init__.py"),
+        str(base / "Lib" / "site-packages" / "superlocalmemory" / "__init__.py"),
+        str(base / "lib" / "site-packages" / "superlocalmemory" / "__init__.py"),
+    ]
+    matches: list[str] = []
+    for pattern in patterns:
+        matches.extend(glob.glob(pattern))
+    for init_path in sorted(set(matches)):
+        try:
+            text = Path(init_path).read_text(encoding="utf-8", errors="replace")
+            for line in text.splitlines():
+                line = line.strip()
+                if line.startswith("__version__"):
+                    # __version__ = "4.1.0"  or  __version__ = '4.1.0'
+                    parts = line.split("=", 1)
+                    if len(parts) == 2:
+                        return parts[1].strip().strip("\"'")
+        except OSError:
+            continue
+    return None
+
+
+def _read_npm_version(npm_root: Path) -> Optional[str]:
+    """Read version from npm global package.json."""
+    pkg_json = npm_root / "superlocalmemory" / "package.json"
+    try:
+        data = json.loads(pkg_json.read_text(encoding="utf-8"))
+        return str(data.get("version", "")).strip() or None
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def _detect_all_installs() -> list[dict]:
+    """Return all SuperLocalMemory installs detected on this machine.
+
+    Each entry is a dict with keys:
+      - ``path``    (str) — directory of the install
+      - ``version`` (str) — version string read from package metadata
+      - ``type``    (str) — one of "pipx", "venv", "npm"
+
+    Detection is read-only and best-effort. A missing or unreadable install
+    produces no entry rather than an error. Subprocess calls are bounded to
+    5 seconds total.
+    """
+    results: list[dict] = []
+
+    # --- pipx ---
+    pipx_version = _read_python_version(_PIPX_ROOT)
+    if pipx_version is not None:
+        results.append({
+            "path": str(_PIPX_ROOT) + "/",
+            "version": pipx_version,
+            "type": "pipx",
+        })
+
+    # --- ~/.slm-venv ---
+    venv_version = _read_python_version(_VENV_ROOT)
+    if venv_version is not None:
+        results.append({
+            "path": str(_VENV_ROOT) + "/",
+            "version": venv_version,
+            "type": "venv",
+        })
+
+    # --- npm global ---
+    npm_root = _npm_global_root()
+    if npm_root is not None:
+        npm_version = _read_npm_version(npm_root)
+        if npm_version is not None:
+            results.append({
+                "path": str(npm_root / "superlocalmemory") + "/",
+                "version": npm_version,
+                "type": "npm",
+            })
+
+    return results
+
+
+__all__ = ["_detect_all_installs"]

package/src/superlocalmemory/core/progressive_abstraction.py

@@ -16,7 +16,7 @@ The persona is one bounded roll-up per profile that consumes the top community
 summaries. It is recall-GATED (never auto-injected into the hot recall path —
 avoids the V3.4.40 summary-pollution regression) and SIZE-bounded. Drill-down
 (``get_sources``) walks the hierarchy back down to the source atoms, matching
-the market bar for summary->source provenance (Zep-style).
+the design goal for summary->source provenance (Zep-style attribution).
 
 Runs in the background consolidation lane after community summaries.
 Fail-open throughout; recompute replaces a profile's row.

package/src/superlocalmemory/core/recall_worker.py

@@ -106,6 +106,10 @@ def _handle_recall(
         memory_map=memory_map,
         per_fact_max=getattr(_rc, "recall_per_fact_max_chars", 2400),
         total_max=getattr(_rc, "recall_total_max_chars", 12000),
+        # Option B: markers only on session-bearing recalls. A marker can
+        # only buy a learning signal when a pending_outcomes row exists
+        # to settle, and those exist only when session_id is present.
+        include_marker=bool(session_id),
     )
     return {
         "ok": True,