superlocalmemory 3.6.13 → 3.6.15

package/src/superlocalmemory/core/engine.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from superlocalmemory.core.config import SLMConfig
+from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT, SLMConfig
 from superlocalmemory.core.engine_capabilities import Capabilities, CapabilityError
 from superlocalmemory.core.modes import get_capabilities
 from superlocalmemory.storage.models import (
@@ -164,6 +164,25 @@ class MemoryEngine:
         except Exception as exc:
             logger.warning("V3.4.6 schema migration failed: %s", exc)
 
+        # v3.6.15: apply ALL pending migrations — including DEFERRED ones like
+        # M016 (scope/shared_with columns) — for DIRECT-engine usage: `slm
+        # remember --sync`, the Python API, and LangChain/CrewAI integrations.
+        # Previously only the daemon lifespan ran apply_deferred, so an existing
+        # pre-3.6.15 database used WITHOUT the daemon hit
+        # "table memories has no column named scope" on the first scoped write.
+        # Idempotent (skips applied migrations) + non-fatal; mirrors the daemon.
+        try:
+            from superlocalmemory.storage.migration_runner import (
+                apply_all, apply_deferred,
+            )
+            _base = self._config.base_dir
+            _learning_db = _base / "learning.db"
+            _memory_db = self._db.db_path
+            apply_all(_learning_db, _memory_db)
+            apply_deferred(_learning_db, _memory_db)
+        except Exception as exc:
+            logger.warning("v3.6.15 deferred migration apply failed: %s", exc)
+
         # V3.4.7: Apply "Learning Brain" schema (tool_events, behavioral_assertions)
         try:
             from superlocalmemory.storage.schema_v347 import apply_v347_schema
@@ -332,7 +351,25 @@ class MemoryEngine:
         logger.info("Processing %d pending memories from async store", len(pending))
         for item in pending:
             try:
-                self.store(item["content"])
+                # v3.6.15 multi-scope: the pending row carries a metadata JSON
+                # blob that may hold scope/shared_with (written by the async
+                # /remember path). Replay them so a queued ``--scope global``
+                # write lands as global, not silently downgraded to personal.
+                import json as _json
+                meta = item.get("metadata")
+                if isinstance(meta, str):
+                    try:
+                        meta = _json.loads(meta) if meta else {}
+                    except (ValueError, TypeError):
+                        meta = {}
+                if not isinstance(meta, dict):
+                    meta = {}
+                _scope = meta.get("scope") or "personal"
+                _shared = meta.get("shared_with")
+                self.store(
+                    item["content"], metadata=meta or None,
+                    scope=_scope, shared_with=_shared,
+                )
                 mark_done(item["id"], base_dir)
             except Exception as exc:
                 logger.warning("Pending memory %d failed: %s", item["id"], exc)
@@ -348,8 +385,15 @@ class MemoryEngine:
         speaker: str = "",
         role: str = "user",
         metadata: dict[str, Any] | None = None,
+        *,
+        scope: str = "personal",
+        shared_with: list[str] | None = 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 the visibility (personal/shared/global).
+        ``shared_with`` is a list of profile_ids for shared scope.
+        """
         self._require_full("store")
         self._ensure_init()
 
@@ -358,6 +402,7 @@ class MemoryEngine:
             content, self._profile_id,
             session_id=session_id, session_date=session_date,
             speaker=speaker, role=role, metadata=metadata,
+            scope=scope, shared_with=shared_with,
             config=self._config, db=self._db,
             embedder=self._embedder,
             fact_extractor=self._fact_extractor,
@@ -397,7 +442,10 @@ class MemoryEngine:
             vector_store=self._vector_store,
         )
 
-    def store_fast(self, content: str, metadata: dict[str, Any] | None = None) -> list[str]:
+    def store_fast(
+        self, content: str, metadata: dict[str, Any] | None = None,
+        *, scope: str = "personal", shared_with: list[str] | None = None,
+    ) -> list[str]:
         """v3.5.5 WRITE-THROUGH: synchronous verbatim insert for IMMEDIATE recall.
 
         Full ``store()`` blocks 30-180s on LLM fact-extraction + Ollama embedding
@@ -455,6 +503,7 @@ class MemoryEngine:
             session_date=now[:10],
             session_id=(metadata or {}).get("session_id", ""),
             metadata=metadata or {},
+            scope=scope, shared_with=shared_with,
         )
         self._db.store_memory(record)
         # Lightweight regex entities (matches store_pipeline verbatim path) so
@@ -485,6 +534,7 @@ class MemoryEngine:
             observation_date=now[:10], confidence=0.7, importance=0.5,
             embedding=emb, fisher_mean=fmean, fisher_variance=fvar,
             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.
@@ -507,10 +557,13 @@ class MemoryEngine:
 
     def recall(
         self, query: str, profile_id: str | None = None,
-        mode: Mode | None = None, limit: int = 20,
+        mode: Mode | None = None, limit: int = CANONICAL_RECALL_LIMIT,
         agent_id: str = "unknown",
         session_id: str | None = None,
         fast: bool = False,
+        *,
+        include_global: bool | None = None,
+        include_shared: bool | None = None,
     ) -> RecallResponse:
         """Recall relevant facts for a query.
 
@@ -526,10 +579,26 @@ class MemoryEngine:
         neighbor-cache fix; fast=True is slower than fast=False and reduces
         recall quality. The parameter is accepted for backward compatibility
         but is silently treated as False.
+
+        Multi-scope: ``include_global`` / ``include_shared`` control which
+        scopes participate in retrieval. ``None`` (the default) means "use the
+        configured ScopeConfig default", which ships OFF — shared memory is
+        opt-in (v3.6.15). Personal facts are ALWAYS returned regardless, so a
+        config of False reproduces 3.6.14 pure-isolation behaviour exactly.
+        This is the single policy chokepoint: every recall path (CLI, MCP,
+        daemon HTTP, in-process adapter) flows through here, so a caller that
+        forgets to thread the flag still gets the safe configured default.
         """
         self._require_full("recall")
         self._ensure_init()
 
+        # Resolve None → configured ScopeConfig default (shared-off by default).
+        _scope_cfg = getattr(self._config, "scope", None)
+        if include_global is None:
+            include_global = bool(getattr(_scope_cfg, "recall_include_global", False))
+        if include_shared is None:
+            include_shared = bool(getattr(_scope_cfg, "recall_include_shared", False))
+
         if fast:
             logger.warning(
                 "fast=True is deprecated (v3.6.9): SpreadingActivation now "
@@ -552,6 +621,8 @@ class MemoryEngine:
             access_log=self._access_log,
             auto_linker=self._auto_linker,
             fast=fast,
+            include_global=include_global,
+            include_shared=include_shared,
         )
 
         # S9-DASH-02: enqueue for pending_outcomes. Non-blocking; errors

package/src/superlocalmemory/core/fact_consolidator.py

@@ -190,7 +190,8 @@ def _consolidate_cluster(
     # Load fact contents including canonical_entities_json
     placeholders = ",".join("?" * len(fact_ids))
     facts = c.execute(
-        f"SELECT fact_id, content, confidence, created_at, canonical_entities_json "
+        f"SELECT fact_id, content, confidence, created_at, canonical_entities_json, "
+        f"scope, shared_with "
         f"FROM atomic_facts "
         f"WHERE fact_id IN ({placeholders}) ORDER BY created_at",
         fact_ids,
@@ -215,6 +216,21 @@ def _consolidate_cluster(
         now = datetime.now(timezone.utc).isoformat()
         avg_confidence = sum(f["confidence"] or 0.5 for f in facts) / len(facts)
 
+        # v3.6.15 multi-scope: a summary must never be MORE visible than its
+        # sources, or it would leak a private fact into a shared/global summary.
+        # Preserve scope only when the whole cluster agrees; any mix (or shared
+        # facts with differing targets) falls back to 'personal' — the most
+        # restrictive scope. All-personal clusters (the common case) are
+        # unchanged. shared_with is preserved only for a uniform shared cluster.
+        _src_scopes = {(f["scope"] or "personal") for f in facts}
+        _src_shared = {f["shared_with"] for f in facts}
+        if _src_scopes == {"global"}:
+            _sum_scope, _sum_shared = "global", None
+        elif _src_scopes == {"shared"} and len(_src_shared) == 1:
+            _sum_scope, _sum_shared = "shared", facts[0]["shared_with"]
+        else:
+            _sum_scope, _sum_shared = "personal", None
+
         # Collect entities from ALL source facts (already in the SELECT)
         all_entities = set()
         raw_entities = set()
@@ -253,13 +269,14 @@ def _consolidate_cluster(
                 (fact_id, memory_id, profile_id, content, fact_type,
                  entities_json, canonical_entities_json,
                  confidence, importance, evidence_count, access_count,
-                 created_at, lifecycle)
-                VALUES (?, '', ?, ?, 'semantic', ?, ?, ?, 0.8, ?, 0, ?, 'active')
+                 created_at, lifecycle, scope, shared_with)
+                VALUES (?, '', ?, ?, 'semantic', ?, ?, ?, 0.8, ?, 0, ?, 'active', ?, ?)
             """, (
                 new_fact_id, profile_id, summary,
                 json.dumps(list(all_entities)),
                 json.dumps(list(all_entities)),
                 round(avg_confidence, 3), len(facts), now,
+                _sum_scope, _sum_shared,
             ))
 
         # Record the consolidation

package/src/superlocalmemory/core/platform_utils.py

@@ -64,6 +64,10 @@ def is_pid_alive(pid: int) -> bool:
         try:
             os.kill(pid, 0)
             return True
+        except ProcessLookupError:
+            return False  # ESRCH — no such process
+        except PermissionError:
+            return True   # EPERM — process EXISTS, we just can't signal it
         except OSError:
             return False
     try:
@@ -73,6 +77,10 @@ def is_pid_alive(pid: int) -> bool:
         try:
             os.kill(pid, 0)
             return True
+        except ProcessLookupError:
+            return False  # ESRCH — no such process
+        except PermissionError:
+            return True   # EPERM — process EXISTS, we just can't signal it
         except OSError:
             return False
 

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/claude_code_hooks.py

@@ -266,7 +266,12 @@ def _remove_slm_hooks(settings: dict) -> dict:
 
 
 def _read_settings() -> dict:
-    """Read Claude Code settings.json, return empty dict if missing."""
+    """Read Claude Code settings.json, return empty dict if missing.
+
+    Raises:
+        json.JSONDecodeError: propagated as-is when the file exists but is
+            malformed, so callers can distinguish 'missing' from 'corrupt'.
+    """
     if CLAUDE_SETTINGS.exists():
         return json.loads(CLAUDE_SETTINGS.read_text())
     return {}
@@ -356,6 +361,8 @@ def check_status() -> dict:
 
     hook_types_found: list[str] = []
     has_gate = False
+    parse_error: str | None = None
+
     try:
         settings = _read_settings()
         for hook_type, entries in settings.get("hooks", {}).items():
@@ -373,12 +380,26 @@ def check_status() -> dict:
                     break
             if has_gate:
                 break
+    except json.JSONDecodeError as exc:
+        # File exists but is malformed — report indeterminate state so callers
+        # do not conflate 'corrupt' with 'not installed'. Claude Code reads the
+        # file independently; hooks may still be firing even though we cannot
+        # parse the file here (split-brain scenario).
+        parse_error = f"JSON parse error in settings.json: {exc}"
+        logger.warning("SLM: %s", parse_error)
     except Exception:
         pass
 
-    installed = len(hook_types_found) >= 3
+    # Three-valued installed:
+    #   True  — enough SLM hook types found (≥3)
+    #   False — file missing or parseable but no SLM hooks
+    #   None  — file exists but is corrupt (indeterminate)
+    if parse_error is not None:
+        installed: bool | None = None
+    else:
+        installed = len(hook_types_found) >= 3
 
-    return {
+    result: dict = {
         "installed": installed,
         "version": installed_version,
         "latest_version": HOOKS_VERSION,
@@ -386,6 +407,9 @@ def check_status() -> dict:
         "hook_types": hook_types_found,
         "gate_enabled": has_gate,
     }
+    if parse_error is not None:
+        result["error"] = parse_error
+    return result
 
 
 def upgrade_hooks() -> dict: