superlocalmemory 3.6.14 → 3.6.15

package/src/superlocalmemory/cli/commands.py

@@ -94,6 +94,48 @@ def _cmd_help_optimize(args: Namespace) -> None:
 # ---- end SLM v3.6 Optimize dispatch functions ----
 
 
+def cmd_session(args: Namespace) -> None:
+    """#49: Open/close a session locally via the daemon — no model roundtrip,
+    so a shell hook (e.g. Claude session-start / /quit) can call it directly.
+    """
+    from superlocalmemory.cli.daemon import (
+        daemon_request, ensure_daemon, is_daemon_running,
+    )
+
+    action = getattr(args, "session_command", None)
+    if action not in ("open", "close"):
+        print("Usage: slm session {open|close} "
+              "[--session-id ID] [--project-path PATH] [--query Q]")
+        return
+
+    if not is_daemon_running():
+        ensure_daemon()
+
+    if action == "open":
+        body = {
+            "project_path": getattr(args, "project_path", "") or "",
+            "query": getattr(args, "query", "") or "",
+            "max_results": int(getattr(args, "max_results", 10) or 10),
+        }
+        resp = daemon_request("POST", "/session/open", body)
+        if resp and resp.get("ok"):
+            print(f"Session opened — warmed {resp.get('warmed', 0)} memories "
+                  f"(query: {resp.get('query', '')})")
+        else:
+            print("Session open failed (daemon unreachable?)")
+        return
+
+    # close
+    body = {"session_id": getattr(args, "session_id", "") or ""}
+    resp = daemon_request("POST", "/session/close", body)
+    if resp and resp.get("ok"):
+        sid = resp.get("session_id") or "(most recent)"
+        print(f"Session closed: {sid} — "
+              f"{resp.get('summary_events_created', 0)} summary event(s) created")
+    else:
+        print("Session close failed (daemon unreachable?)")
+
+
 def dispatch(args: Namespace) -> None:
     """Route CLI command to the appropriate handler."""
     # Auto-install/upgrade hooks on version change (single file read, ~0.1ms)
@@ -128,6 +170,7 @@ def dispatch(args: Namespace) -> None:
         "profile": cmd_profile,
         "hooks": cmd_hooks,
         "session-context": cmd_session_context,
+        "session": cmd_session,  # #49: local session open/close for hooks
         "observe": cmd_observe,
         # V3.3 commands
         "decay": cmd_decay,
@@ -993,6 +1036,19 @@ def cmd_remember(args: Namespace) -> None:
 
     use_json = getattr(args, 'json', False)
     sync_mode = getattr(args, 'sync_mode', False)
+    # v3.6.15 multi-scope: scope=None means "not specified" → resolve to the
+    # configured default_scope (personal) at the daemon / engine boundary.
+    # Shared memory is opt-in, so an unset --scope always stays private.
+    scope = getattr(args, 'scope', None)
+    # v3.6.15: --shared-with is a comma-separated string on the CLI, but the
+    # daemon (RememberRequest) and engine expect list[str]. Parse here so an
+    # explicit `--shared-with a,b` doesn't 422 at the daemon and silently fall
+    # back to a personal write.
+    _sw_raw = getattr(args, 'shared_with', None)
+    shared_with = (
+        [s.strip() for s in _sw_raw.split(",") if s.strip()]
+        if isinstance(_sw_raw, str) and _sw_raw.strip() else _sw_raw
+    )
 
     # V3.3.21: Route through daemon for instant remember (no cold start).
     # If daemon is running, send request directly (~0.1s).
@@ -1005,6 +1061,8 @@ def cmd_remember(args: Namespace) -> None:
                 result = daemon_request("POST", "/remember", {
                     "content": args.content,
                     "tags": args.tags or "",
+                    "scope": scope,
+                    "shared_with": shared_with,
                 })
                 if result and "fact_ids" in result:
                     if use_json:
@@ -1020,9 +1078,20 @@ def cmd_remember(args: Namespace) -> None:
         # NO subprocess spawn. Daemon's background loop picks up pending memories.
         from superlocalmemory.cli.pending_store import store_pending
 
+        # v3.6.15 multi-scope: carry an explicit non-personal scope into the
+        # pending row's metadata so the materializer replays the right
+        # visibility. Unset / personal carries nothing — byte-identical to
+        # pre-3.6.15 pending rows.
+        _pending_meta = None
+        if scope and scope != "personal":
+            _pending_meta = {"scope": scope}
+            if shared_with:
+                _pending_meta["shared_with"] = shared_with
+
         row_id = store_pending(
             content=args.content,
             tags=args.tags or "",
+            metadata=_pending_meta,
         )
 
         if use_json:
@@ -1040,8 +1109,13 @@ def cmd_remember(args: Namespace) -> None:
         engine = MemoryEngine(config)
         engine.initialize()
 
+        # v3.6.15: resolve an unset scope to the configured default_scope.
+        _scope = scope or getattr(getattr(config, "scope", None), "default_scope", "personal")
         metadata = {"tags": args.tags} if args.tags else {}
-        fact_ids = engine.store(args.content, metadata=metadata)
+        fact_ids = engine.store(
+            args.content, metadata=metadata,
+            scope=_scope, shared_with=shared_with,
+        )
     except Exception as exc:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
@@ -1064,6 +1138,11 @@ def cmd_remember(args: Namespace) -> None:
 def cmd_recall(args: Namespace) -> None:
     """Search memories via the engine — routes through daemon if available."""
     use_json = getattr(args, 'json', False)
+    # v3.6.15: None = "not specified" → daemon/engine resolves the configured
+    # default (shared-off). Only an explicit --include-global / --no-global
+    # produces True/False here.
+    include_global = getattr(args, 'include_global', None)
+    include_shared = getattr(args, 'include_shared', None)
 
     # V3.3.21: Route through daemon for instant response (no cold start).
     # Falls back to direct engine if daemon not running.
@@ -1077,10 +1156,18 @@ def cmd_recall(args: Namespace) -> None:
             from urllib.parse import quote
             session_id = f"cli:{os.getppid()}"
             fast_qs = "&fast=true" if getattr(args, "fast", False) else ""
+            # Only send scope flags when the user set them explicitly; absent =
+            # let the daemon resolve the configured default. (Never emit
+            # "none" — that would parse as a missing/false value.)
+            scope_qs = ""
+            if include_global is not None:
+                scope_qs += f"&include_global={str(include_global).lower()}"
+            if include_shared is not None:
+                scope_qs += f"&include_shared={str(include_shared).lower()}"
             result = daemon_request(
                 "GET",
                 f"/recall?q={quote(args.query)}&limit={args.limit}"
-                f"&session_id={quote(session_id)}{fast_qs}",
+                f"&session_id={quote(session_id)}{fast_qs}{scope_qs}",
             )
             if result and "results" in result:
                 # Format daemon response same as engine response
@@ -1114,6 +1201,8 @@ def cmd_recall(args: Namespace) -> None:
         response = engine.recall(
             args.query, limit=args.limit,
             fast=getattr(args, "fast", False),
+            include_global=include_global,
+            include_shared=include_shared,
         )
     except Exception as exc:
         if use_json:

package/src/superlocalmemory/cli/main.py

@@ -235,6 +235,15 @@ def main() -> None:
         "--sync", dest="sync_mode", action="store_true",
         help="Wait for completion (default: async background processing)",
     )
+    remember_p.add_argument(
+        "--scope", default=None, choices=("personal", "shared", "global"),
+        help="Memory scope: personal, shared, or global. Unset uses the "
+             "configured default_scope (personal). Shared memory is opt-in.",
+    )
+    remember_p.add_argument(
+        "--shared-with", default=None,
+        help="Comma-separated profile IDs for shared scope",
+    )
 
     # v3.6.12 (parity-3): `search` is an alias of `recall` so the CLI has the
     # same search verb the MCP exposes (handlers dict maps both to cmd_recall).
@@ -251,6 +260,26 @@ def main() -> None:
              "Other 4 channels (semantic, lexical, temporal, structural) still run. "
              "Use when you need recall before a tool call (e.g. before WebSearch).",
     )
+    # v3.6.15: shared memory is opt-in. Unset (None) → resolve the configured
+    # default (recall_include_global/shared, both False by default). Explicit
+    # flags override per-call. default=None on BOTH members of each pair so the
+    # store_false's implicit default=True can't sneak back in.
+    recall_p.add_argument(
+        "--include-global", dest="include_global", action="store_true", default=None,
+        help="Include global-scope facts in retrieval (opt-in; default off)",
+    )
+    recall_p.add_argument(
+        "--no-global", dest="include_global", action="store_false", default=None,
+        help="Exclude global-scope facts from retrieval",
+    )
+    recall_p.add_argument(
+        "--include-shared", dest="include_shared", action="store_true", default=None,
+        help="Include facts shared with this profile (opt-in; default off)",
+    )
+    recall_p.add_argument(
+        "--no-shared", dest="include_shared", action="store_false", default=None,
+        help="Exclude shared-scope facts from retrieval",
+    )
 
     forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
     forget_p.add_argument("query", help="Query to match for deletion")
@@ -380,6 +409,22 @@ def main() -> None:
     )
     ctx_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
+    # #49: local session open/close (for hooks; no model roundtrip)
+    session_p = sub.add_parser(
+        "session", help="Open/close a session locally (for hooks; no model roundtrip)"
+    )
+    session_sub = session_p.add_subparsers(dest="session_command", title="session actions")
+    sopen_p = session_sub.add_parser("open", help="Warm session context")
+    sopen_p.add_argument("--project-path", default="", help="Project path to derive the warm query")
+    sopen_p.add_argument("--query", default="", help="Explicit warm query")
+    sopen_p.add_argument("--max-results", type=int, default=10, help="Max memories to warm (default 10)")
+    sclose_p = session_sub.add_parser(
+        "close", help="Close session, create temporal summaries"
+    )
+    sclose_p.add_argument(
+        "--session-id", default="", help="Session to close (default: most recent)"
+    )
+
     obs_p = sub.add_parser("observe", help="Auto-capture content (pipe or argument)")
     obs_p.add_argument("content", nargs="?", default="", help="Content to evaluate")
 

package/src/superlocalmemory/cli/setup_wizard.py

@@ -379,6 +379,33 @@ def run_wizard(auto: bool = False) -> None:
     mode_map = {"a": Mode.A, "b": Mode.B, "c": Mode.C}
     config = SLMConfig.for_mode(mode_map[choice])
 
+    # -- Multi-scope (shared memory) opt-in — v3.6.15 --
+    # OFF by default: your memories stay private to this profile (3.6.14 behaviour).
+    # Enabling only turns ON recall VISIBILITY of other profiles' shared/global facts;
+    # your own writes still default to 'personal' (mark a memory shared/global per call
+    # with --scope). Existing users can flip this later in the `scope` section of
+    # mode_a/b/c.json. See docs/shared-memory.md.
+    print()
+    print("  Shared memory lets other local profiles' 'shared'/'global' memories")
+    print("  appear in your recall. It is OFF by default — your memories stay private.")
+    if interactive:
+        sm_choice = _prompt(
+            "  See shared/global memories from other profiles by default? [y/N] (default: N): ",
+            "n",
+        ).lower()
+    else:
+        sm_choice = "n"
+    if sm_choice in ("y", "yes"):
+        from superlocalmemory.core.config import ScopeConfig
+        config.scope = ScopeConfig(
+            default_scope="personal",
+            recall_include_global=True,
+            recall_include_shared=True,
+        )
+        print("  ✓ Shared-memory recall ENABLED (your own writes still default to personal).")
+    else:
+        print("  ✓ Shared memory OFF (default) — enable later in mode_*.json if needed.")
+
     if choice == "b":
         print()
         if shutil.which("ollama"):

package/src/superlocalmemory/core/backend_orchestrator.py

@@ -342,15 +342,15 @@ class BackendOrchestrator:
                         count: int = 0, error: str = "") -> None:
         self._backend_cache[name] = status
         try:
-            self._db.conn.execute(
+            # #47 fix: DatabaseManager has no `.conn`; execute() commits itself.
+            self._db.execute(
                 "INSERT OR REPLACE INTO backend_status "
                 "(backend_name, status, record_count, error_message, last_sync_at) "
                 "VALUES (?, ?, ?, ?, datetime('now'))",
                 (name, status, count, error),
             )
-            self._db.conn.commit()
-        except Exception:
-            pass
+        except Exception as exc:
+            logger.debug("backend_status update failed for %s: %s", name, exc)
 
     # ------------------------------------------------------------------
     # Internal: Schema
@@ -361,10 +361,14 @@ class BackendOrchestrator:
             from superlocalmemory.storage.schema_v345 import (
                 apply_migration, schema_version_applied,
             )
-            if not schema_version_applied(self._db.conn):
-                result = apply_migration(self._db.conn)
-                if result.get("errors"):
-                    logger.warning("Schema v3.4.5 had errors: %s", result["errors"])
+            # #47 fix: use raw_connection() — DatabaseManager has no `.conn`,
+            # so the old code raised AttributeError that was silently swallowed,
+            # leaving the v3.4.5 migration (access_count_30d) permanently unapplied.
+            with self._db.raw_connection() as conn:
+                if not schema_version_applied(conn):
+                    result = apply_migration(conn)
+                    if result.get("errors"):
+                        logger.warning("Schema v3.4.5 had errors: %s", result["errors"])
         except ImportError:
             logger.debug("schema_v345 not found — skipping")
         except Exception as exc:

package/src/superlocalmemory/core/config.py

@@ -129,6 +129,79 @@ class ChannelWeights:
         }
 
 
+# ---------------------------------------------------------------------------
+# Scope Weights
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ScopeWeights:
+    """RRF fusion weights for multi-scope retrieval.
+
+    Personal scope has highest weight (most relevant to current profile).
+    Shared scope has medium weight (team/group memories).
+    Global scope has lowest weight (public/common knowledge).
+    """
+
+    personal: float = 1.0
+    shared: float = 0.7
+    global_: float = 0.5  # trailing underscore avoids Python keyword
+
+    def __post_init__(self) -> None:
+        for name in ("personal", "shared", "global_"):
+            val = getattr(self, name)
+            if val < 0:
+                raise ValueError(f"ScopeWeights values must be non-negative, got {name}={val}")
+
+    def as_dict(self) -> dict[str, float]:
+        return {"personal": self.personal, "shared": self.shared, "global": self.global_}
+
+
+# ---------------------------------------------------------------------------
+# Scope Config (multi-scope memory behaviour defaults)
+# ---------------------------------------------------------------------------
+
+_VALID_SCOPES = ("personal", "shared", "global")
+
+
+@dataclass
+class ScopeConfig:
+    """User-facing defaults for multi-scope (shared) memory.
+
+    SHARED MEMORY IS OPT-IN — NOT a default feature (v3.6.15 product decision).
+    The defaults below make a fresh / unconfigured install behave EXACTLY like
+    3.6.14: every write is ``personal`` and recall returns only this profile's
+    own facts. Another profile's ``global``/``shared`` facts never leak into
+    recall until the user explicitly turns sharing on.
+
+      - ``default_scope='personal'``      → writes stay private by default;
+      - ``recall_include_global=False``   → don't surface other profiles' global;
+      - ``recall_include_shared=False``   → don't surface facts shared *to* me.
+
+    Turning it on is a deliberate act, done either per-call (``--scope`` /
+    ``--include-global`` / MCP args) or persistently by editing config.json /
+    mode_a|b|c.json (the installer can also write the choice). The CLI/MCP
+    boundary passes ``None`` ("not specified") so the engine resolves these
+    config values as the effective default.
+    """
+
+    default_scope: str = "personal"         # scope assigned to new memories
+    recall_include_global: bool = False     # surface scope='global' facts in recall
+    recall_include_shared: bool = False     # surface scope='shared' facts in recall
+
+    def __post_init__(self) -> None:
+        if self.default_scope not in _VALID_SCOPES:
+            raise ValueError(
+                f"default_scope must be one of {_VALID_SCOPES}, got {self.default_scope!r}"
+            )
+
+    def as_dict(self) -> dict:
+        return {
+            "default_scope": self.default_scope,
+            "recall_include_global": self.recall_include_global,
+            "recall_include_shared": self.recall_include_shared,
+        }
+
+
 # ---------------------------------------------------------------------------
 # Encoding Config
 # ---------------------------------------------------------------------------
@@ -702,6 +775,8 @@ class SLMConfig:
     embedding: EmbeddingConfig = field(default_factory=EmbeddingConfig)
     llm: LLMConfig = field(default_factory=LLMConfig)
     channel_weights: ChannelWeights = field(default_factory=ChannelWeights)
+    scope_weights: ScopeWeights = field(default_factory=ScopeWeights)
+    scope: ScopeConfig = field(default_factory=ScopeConfig)
     encoding: EncodingConfig = field(default_factory=EncodingConfig)
     retrieval: RetrievalConfig = field(default_factory=RetrievalConfig)
     math: MathConfig = field(default_factory=MathConfig)
@@ -860,6 +935,36 @@ class SLMConfig:
             prestage_max_response_bytes=int(inj.get("prestage_max_response_bytes", 64 * 1024)),
         )
 
+        # Multi-scope memory: scope weights
+        sw = data.get("scope_weights", {})
+        if sw:
+            # v3.6.15: a malformed value (e.g. negative weight) must NOT brick
+            # every `slm` command via an uncaught ValueError out of load().
+            # Fall back to defaults and warn — the config is recoverable.
+            try:
+                config.scope_weights = ScopeWeights(**{
+                    k: v for k, v in sw.items()
+                    if k in ScopeWeights.__dataclass_fields__
+                })
+            except (ValueError, TypeError) as exc:
+                logger.warning(
+                    "Ignoring invalid scope_weights in config (%s) — using defaults", exc
+                )
+
+        # Multi-scope memory: behaviour defaults (default scope + recall visibility)
+        sc = data.get("scope", {})
+        if sc:
+            # Same guard: a typo'd default_scope must not crash the whole CLI.
+            try:
+                config.scope = ScopeConfig(**{
+                    k: v for k, v in sc.items()
+                    if k in ScopeConfig.__dataclass_fields__
+                })
+            except (ValueError, TypeError) as exc:
+                logger.warning(
+                    "Ignoring invalid scope config (%s) — using shared-off defaults", exc
+                )
+
         return config
 
     def save(
@@ -952,6 +1057,16 @@ class SLMConfig:
             "prestage_max_response_bytes": self.injection.prestage_max_response_bytes,
         }
 
+        # Multi-scope memory: scope weights
+        data["scope_weights"] = {
+            "personal": self.scope_weights.personal,
+            "shared": self.scope_weights.shared,
+            "global_": self.scope_weights.global_,
+        }
+
+        # Multi-scope memory: behaviour defaults
+        data["scope"] = self.scope.as_dict()
+
         # Preserve existing V3.3 config sections that aren't in for_mode()
         for key in ("forgetting", "quantization", "sagq", "embedding_signature", "auto_invoke"):
             if key in existing:

package/src/superlocalmemory/core/engine.py

@@ -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.
@@ -511,6 +561,9 @@ class MemoryEngine:
         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