superlocalmemory 3.6.13 → 3.6.15

package/src/superlocalmemory/storage/database.py

@@ -43,6 +43,49 @@ _MAX_RETRIES = 5            # retry on transient SQLITE_BUSY
 _RETRY_BASE_DELAY = 0.1    # seconds — exponential backoff base
 
 
+def _scope_where(
+    profile_id: str,
+    *,
+    include_global: bool = False,
+    include_shared: bool = False,
+    prefix: str = "",
+) -> tuple[str, list]:
+    """Build scope-filtering WHERE clause for multi-scope retrieval.
+
+    Returns ``(where_clause, params)`` for splicing into SQL queries.
+
+    When ``include_global=True``, facts with ``scope='global'`` are included
+    regardless of profile. When ``include_shared=True``, facts explicitly
+    shared with this profile (via ``shared_with`` JSON array) are also
+    included.
+
+    v3.6.15: defaults are SHARED-OFF (include_global/include_shared=False) so
+    any DIRECT caller (search, list_recent, fetch, resources) is private by
+    default — shared memory is opt-in. The recall channels pass explicit
+    resolved flags, so opt-in recall is unaffected. With both False the clause
+    collapses to ``profile_id = ?`` — identical to 3.6.14 isolation.
+    """
+    table = f"{prefix}." if prefix else ""
+    clauses = [f"({table}profile_id = ?)"]
+    params: list = [profile_id]
+
+    if include_global:
+        clauses.append(f"({table}scope = 'global')")
+
+    if include_shared:
+        # Match the profile_id as a quoted JSON-array element. ESCAPE the LIKE
+        # metacharacters in profile_id so a profile id containing % or _ cannot
+        # false-positive-match another profile's shared_with list.
+        _esc = profile_id.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+        clauses.append(
+            f"({table}scope = 'shared' AND {table}shared_with LIKE ? ESCAPE '\\')"
+        )
+        params.append(f'%"{_esc}"%')
+
+    where = "(" + " OR ".join(clauses) + ")"
+    return where, params
+
+
 class DatabaseManager:
     """Concurrent-safe SQLite manager with WAL, profile isolation, and FTS5.
 
@@ -115,6 +158,28 @@ class DatabaseManager:
                 self._txn_conn = None
                 conn.close()
 
+    @contextmanager
+    def raw_connection(self) -> Generator[sqlite3.Connection, None, None]:
+        """Yield a live sqlite3.Connection for code that needs one directly.
+
+        For callers (e.g. schema migrations) that must hold a real connection
+        rather than going through execute(). Commits on success, rolls back on
+        error, and always closes — mirroring transaction(). This is the public
+        way to obtain a connection; there is no `.conn` attribute.
+        """
+        with self._lock:
+            conn = self._connect()
+            self._txn_conn = conn
+            try:
+                yield conn
+                conn.commit()
+            except Exception:
+                conn.rollback()
+                raise
+            finally:
+                self._txn_conn = None
+                conn.close()
+
     def execute(self, sql: str, params: tuple[Any, ...] = ()) -> list[sqlite3.Row]:
         """Execute SQL with automatic retry on SQLITE_BUSY.
 
@@ -149,15 +214,18 @@ class DatabaseManager:
 
     def store_memory(self, record: MemoryRecord) -> str:
         """Persist a raw memory record. Returns memory_id."""
+        _scope = getattr(record, 'scope', None) or 'personal'
+        _shared = _jd(getattr(record, 'shared_with', None))
         self.execute(
             """INSERT OR REPLACE INTO memories
                (memory_id, profile_id, content, session_id, speaker,
-                role, session_date, created_at, metadata_json)
-               VALUES (?,?,?,?,?,?,?,?,?)""",
+                role, session_date, created_at, metadata_json,
+                scope, shared_with)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
             (record.memory_id, record.profile_id, record.content,
              record.session_id, record.speaker, record.role,
              record.session_date, record.created_at,
-             json.dumps(record.metadata)),
+             json.dumps(record.metadata), _scope, _shared),
         )
         return record.memory_id
 
@@ -229,6 +297,8 @@ class DatabaseManager:
                 # orphaned id that was never inserted.
                 fact.fact_id = canonical_id
                 return canonical_id
+        _scope = getattr(fact, 'scope', None) or 'personal'
+        _shared = _jd(getattr(fact, 'shared_with', None))
         self.execute(
             """INSERT OR REPLACE INTO atomic_facts
                (fact_id, memory_id, profile_id, content, fact_type,
@@ -238,8 +308,9 @@ class DatabaseManager:
                 source_turn_ids_json, session_id,
                 embedding, fisher_mean, fisher_variance,
                 lifecycle, langevin_position,
-                emotional_valence, emotional_arousal, signal_type, created_at)
-               VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                emotional_valence, emotional_arousal, signal_type, created_at,
+                scope, shared_with)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
             (fact.fact_id, fact.memory_id, fact.profile_id, fact.content,
              fact.fact_type.value,
              json.dumps(fact.entities), json.dumps(fact.canonical_entities),
@@ -250,7 +321,7 @@ class DatabaseManager:
              _jd(fact.embedding), _jd(fact.fisher_mean), _jd(fact.fisher_variance),
              fact.lifecycle.value, _jd(fact.langevin_position),
              fact.emotional_valence, fact.emotional_arousal,
-             fact.signal_type.value, fact.created_at),
+             fact.signal_type.value, fact.created_at, _scope, _shared),
         )
         return fact.fact_id
 
@@ -280,6 +351,8 @@ class DatabaseManager:
             emotional_arousal=d.get("emotional_arousal", 0.0),
             signal_type=SignalType(d["signal_type"]) if d.get("signal_type") else SignalType.FACTUAL,
             pinned=bool(d.get("pinned", 0)),
+            scope=d.get("scope", "personal"),
+            shared_with=_jl(d.get("shared_with"), None),
             created_at=d["created_at"],
         )
 
@@ -290,17 +363,29 @@ class DatabaseManager:
             (1 if pinned else 0, fact_id),
         )
 
-    def get_pinned(self, profile_id: str) -> list[AtomicFact]:
+    def get_pinned(
+        self, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[AtomicFact]:
         """Return all pinned facts for a profile, highest-importance first."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM atomic_facts WHERE profile_id = ? AND pinned = 1 "
+            f"SELECT * FROM atomic_facts WHERE {where} AND pinned = 1 "
             "ORDER BY importance DESC",
-            (profile_id,),
+            (*params,),
         )
         return [self._row_to_fact(r) for r in rows]
 
     def get_all_facts(
         self, profile_id: str, limit: int | None = None,
+        *,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> list[AtomicFact]:
         """All facts for a profile, newest first.
 
@@ -308,22 +393,31 @@ class DatabaseManager:
         most-recent N (e.g. the Hopfield channel's 5000 cap) don't deserialize
         the entire table into AtomicFact objects. Default (None) = all facts.
         """
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         if limit is not None:
             rows = self.execute(
-                "SELECT * FROM atomic_facts WHERE profile_id = ? "
+                f"SELECT * FROM atomic_facts WHERE {where} "
                 "ORDER BY created_at DESC LIMIT ?",
-                (profile_id, int(limit)),
+                (*params, int(limit)),
             )
         else:
             rows = self.execute(
-                "SELECT * FROM atomic_facts WHERE profile_id = ? ORDER BY created_at DESC",
-                (profile_id,),
+                f"SELECT * FROM atomic_facts WHERE {where} ORDER BY created_at DESC",
+                (*params,),
             )
         return [self._row_to_fact(r) for r in rows]
 
     _MAX_FACTS_PER_ENTITY_LOOKUP: int = 100
 
-    def get_facts_by_entity(self, entity_id: str, profile_id: str) -> list[AtomicFact]:
+    def get_facts_by_entity(
+        self, entity_id: str, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[AtomicFact]:
         """Facts whose canonical_entities JSON array contains *entity_id*.
 
         V3.3.14: LIMIT to _MAX_FACTS_PER_ENTITY_LOOKUP (100) to prevent
@@ -331,19 +425,33 @@ class DatabaseManager:
         facts for popular entities (500+) causing 17GB+ memory usage.
         Ordered by created_at DESC so newest facts are always included.
         """
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM atomic_facts WHERE profile_id = ? AND canonical_entities_json LIKE ? "
+            f"SELECT * FROM atomic_facts WHERE {where} AND canonical_entities_json LIKE ? "
             "ORDER BY created_at DESC LIMIT ?",
-            (profile_id, f'%"{entity_id}"%', self._MAX_FACTS_PER_ENTITY_LOOKUP),
+            (*params, f'%"{entity_id}"%', self._MAX_FACTS_PER_ENTITY_LOOKUP),
         )
         return [self._row_to_fact(r) for r in rows]
 
-    def get_facts_by_type(self, fact_type: FactType, profile_id: str) -> list[AtomicFact]:
+    def get_facts_by_type(
+        self, fact_type: FactType, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[AtomicFact]:
         """All facts of a given type for a profile."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM atomic_facts WHERE profile_id = ? AND fact_type = ? "
+            f"SELECT * FROM atomic_facts WHERE {where} AND fact_type = ? "
             "ORDER BY created_at DESC",
-            (profile_id, fact_type.value),
+            (*params, fact_type.value),
         )
         return [self._row_to_fact(r) for r in rows]
 
@@ -411,10 +519,19 @@ class DatabaseManager:
             )
         return n
 
-    def get_fact_count(self, profile_id: str) -> int:
+    def get_fact_count(
+        self, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> int:
         """Total fact count for a profile."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT COUNT(*) AS c FROM atomic_facts WHERE profile_id = ?", (profile_id,),
+            f"SELECT COUNT(*) AS c FROM atomic_facts WHERE {where}", (*params,),
         )
         return int(rows[0]["c"]) if rows else 0
 
@@ -481,12 +598,19 @@ class DatabaseManager:
 
     def get_facts_by_memory_id(
         self, memory_id: str, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> list[AtomicFact]:
         """Get all atomic facts for a given memory_id."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM atomic_facts WHERE memory_id = ? AND profile_id = ? "
+            f"SELECT * FROM atomic_facts WHERE memory_id = ? AND {where} "
             "ORDER BY confidence DESC",
-            (memory_id, profile_id),
+            (memory_id, *params),
         )
         return [self._row_to_fact(r) for r in rows]
 
@@ -513,21 +637,33 @@ class DatabaseManager:
                 (edge.weight, canonical_id),
             )
             return canonical_id
+        _scope = getattr(edge, 'scope', None) or 'personal'
+        _shared = _jd(getattr(edge, 'shared_with', None))
         self.execute(
             """INSERT OR REPLACE INTO graph_edges
-               (edge_id, profile_id, source_id, target_id, edge_type, weight, created_at)
-               VALUES (?,?,?,?,?,?,?)""",
+               (edge_id, profile_id, source_id, target_id, edge_type, weight, created_at,
+                scope, shared_with)
+               VALUES (?,?,?,?,?,?,?,?,?)""",
             (edge.edge_id, edge.profile_id, edge.source_id, edge.target_id,
-             edge.edge_type.value, edge.weight, edge.created_at),
+             edge.edge_type.value, edge.weight, edge.created_at, _scope, _shared),
         )
         return edge.edge_id
 
-    def get_edges_for_node(self, node_id: str, profile_id: str) -> list[GraphEdge]:
+    def get_edges_for_node(
+        self, node_id: str, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[GraphEdge]:
         """All edges where node_id is source or target."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM graph_edges WHERE profile_id = ? "
+            f"SELECT * FROM graph_edges WHERE {where} "
             "AND (source_id = ? OR target_id = ?)",
-            (profile_id, node_id, node_id),
+            (*params, node_id, node_id),
         )
         return [
             GraphEdge(
@@ -541,24 +677,36 @@ class DatabaseManager:
 
     def store_temporal_event(self, event: TemporalEvent) -> str:
         """Persist a temporal event. Returns event_id."""
+        _scope = getattr(event, 'scope', None) or 'personal'
+        _shared = _jd(getattr(event, 'shared_with', None))
         self.execute(
             """INSERT OR REPLACE INTO temporal_events
                (event_id, profile_id, entity_id, fact_id,
                 observation_date, referenced_date, interval_start, interval_end,
-                description)
-               VALUES (?,?,?,?,?,?,?,?,?)""",
+                description, scope, shared_with)
+               VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
             (event.event_id, event.profile_id, event.entity_id, event.fact_id,
              event.observation_date, event.referenced_date,
-             event.interval_start, event.interval_end, event.description),
+             event.interval_start, event.interval_end, event.description,
+             _scope, _shared),
         )
         return event.event_id
 
-    def get_temporal_events(self, entity_id: str, profile_id: str) -> list[TemporalEvent]:
+    def get_temporal_events(
+        self, entity_id: str, profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[TemporalEvent]:
         """All temporal events for an entity, newest first."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM temporal_events WHERE profile_id = ? AND entity_id = ? "
+            f"SELECT * FROM temporal_events WHERE {where} AND entity_id = ? "
             "ORDER BY observation_date DESC",
-            (profile_id, entity_id),
+            (*params, entity_id),
         )
         return [
             TemporalEvent(
@@ -588,7 +736,11 @@ class DatabaseManager:
         )
         return {dict(r)["fact_id"]: json.loads(dict(r)["tokens"]) for r in rows}
 
-    def search_facts_fts(self, query: str, profile_id: str, limit: int = 20) -> list[AtomicFact]:
+    def search_facts_fts(
+        self, query: str, profile_id: str, limit: int = 20,
+        include_global: bool = False,
+        include_shared: bool = False,
+    ) -> list[AtomicFact]:
         """Full-text search via FTS5, joined to facts table for reconstruction."""
         # v3.6.12 (search-1): the raw query was passed straight into FTS5 MATCH,
         # so any '?', '-', quote, or trailing boolean keyword (AND/OR/NOT) raised
@@ -599,12 +751,18 @@ class DatabaseManager:
         if not tokens:
             return []
         match_expr = " OR ".join(f'"{t}"' for t in tokens)
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+            prefix="f",
+        )
         rows = self.execute(
-            """SELECT f.* FROM atomic_facts_fts AS fts
+            f"""SELECT f.* FROM atomic_facts_fts AS fts
                JOIN atomic_facts AS f ON f.fact_id = fts.fact_id
-               WHERE fts.atomic_facts_fts MATCH ? AND f.profile_id = ?
+               WHERE fts.atomic_facts_fts MATCH ? AND {where}
                ORDER BY fts.rank LIMIT ?""",
-            (match_expr, profile_id, limit),
+            (match_expr, *params, limit),
         )
         return [self._row_to_fact(r) for r in rows]
 
@@ -641,15 +799,22 @@ class DatabaseManager:
 
     def get_facts_by_ids(
         self, fact_ids: list[str], profile_id: str,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> list[AtomicFact]:
         """Get multiple facts by their IDs, scoped to a profile."""
         if not fact_ids:
             return []
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         placeholders = ",".join("?" for _ in fact_ids)
         rows = self.execute(
             f"SELECT * FROM atomic_facts WHERE fact_id IN ({placeholders}) "
-            f"AND profile_id = ? ORDER BY created_at DESC",
-            (*fact_ids, profile_id),
+            f"AND {where} ORDER BY created_at DESC",
+            (*fact_ids, *params),
         )
         return [self._row_to_fact(r) for r in rows]
 
@@ -820,14 +985,21 @@ class DatabaseManager:
 
     def get_temporal_events_by_range(
         self, profile_id: str, start_date: str, end_date: str,
+        include_global: bool = False,
+        include_shared: bool = False,
     ) -> list[TemporalEvent]:
         """Temporal events within a date range (inclusive)."""
+        where, params = _scope_where(
+            profile_id,
+            include_global=include_global,
+            include_shared=include_shared,
+        )
         rows = self.execute(
-            "SELECT * FROM temporal_events WHERE profile_id = ? "
+            f"SELECT * FROM temporal_events WHERE {where} "
             "AND (referenced_date BETWEEN ? AND ? "
             "     OR observation_date BETWEEN ? AND ?) "
             "ORDER BY observation_date DESC",
-            (profile_id, start_date, end_date, start_date, end_date),
+            (*params, start_date, end_date, start_date, end_date),
         )
         return [
             TemporalEvent(

package/src/superlocalmemory/storage/migration_runner.py

@@ -51,6 +51,7 @@ from superlocalmemory.storage.migrations import (
     M013_bi_temporal_columns as _M013,
     M014_v345_scale_ready as _M014,
     M015_add_pinned_column as _M015,
+    M016_add_scope_support as _M016,
 )
 
 # Map migration name → module (used for the optional ``verify(conn)`` hook
@@ -71,6 +72,7 @@ _MODULES = {
     _M013.NAME: _M013,
     _M014.NAME: _M014,
     _M015.NAME: _M015,
+    _M016.NAME: _M016,
 }
 
 logger = logging.getLogger(__name__)
@@ -134,6 +136,9 @@ DEFERRED_MIGRATIONS: list[Migration] = [
     Migration(name=_M014.NAME, db_target="memory", ddl=_M014.DDL),
     # M015 adds pinned column to atomic_facts (v3.4.65 core-memory pins).
     Migration(name=_M015.NAME, db_target="memory", ddl=_M015.DDL),
+    # M016 adds scope and shared_with columns to 5 core tables for
+    # multi-scope memory support (personal/global/shared).
+    Migration(name=_M016.NAME, db_target="memory", ddl=_M016.DDL),
 ]
 
 
@@ -266,7 +271,18 @@ def _apply_single(
         return ("failed", f"cannot record in_progress: {exc}")
 
     try:
-        conn.executescript(migration.ddl)
+        # A migration module may ship a custom apply(conn) for conditional logic
+        # that static DDL can't express (e.g. SQLite has no ADD COLUMN IF NOT
+        # EXISTS, and ALTER on a missing/already-altered table can't be guarded
+        # in one executescript). If present, it runs instead of the DDL string;
+        # otherwise the DDL is applied as before. Pure-DDL migrations are
+        # unaffected.
+        _mod = _MODULES.get(migration.name)
+        _apply_fn = getattr(_mod, "apply", None) if _mod is not None else None
+        if callable(_apply_fn):
+            _apply_fn(conn)
+        else:
+            conn.executescript(migration.ddl)
     except sqlite3.Error as exc:
         # Best-effort rollback.
         try:

package/src/superlocalmemory/storage/migrations/M016_add_scope_support.py

@@ -0,0 +1,120 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory v3.6.15
+
+"""M016 — scope and shared_with columns on core tables (memory.db, deferred).
+
+Adds two columns to each of the 5 core tables for multi-scope memory support:
+
+    scope       TEXT NOT NULL DEFAULT 'personal'  — personal | global
+    shared_with TEXT                             — JSON array of profile_ids
+
+Existing data retains scope='personal' (backward compatible). Indexes on
+``scope`` and ``(profile_id, scope)`` speed up scope-filtered queries and are
+created HERE (not in schema.create_all_tables) so an upgrading DB whose tables
+predate the scope column doesn't hit "no such column: scope" when the boot-time
+index DDL runs before this migration.
+
+Applied via a conditional apply(conn) rather than static DDL because SQLite has
+no ``ADD COLUMN IF NOT EXISTS``: a static ALTER fails on a fresh install (the
+column already exists from create_all_tables) and on a deferred boot where a
+table isn't created yet. apply() guards every step so it is idempotent and
+tolerant of partial/missing tables.
+
+Deferred like M006, M011, and M013 because the core tables are bootstrapped
+at engine init, not at migration time. Daemon lifespan calls ``apply_deferred``
+right after engine init so these columns materialise on first boot after upgrade.
+
+Author: Varun Pratap Bhardwaj / Qualixar
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M016_add_scope_support"
+DB_TARGET = "memory"
+
+TABLES = [
+    "memories",
+    "atomic_facts",
+    "canonical_entities",
+    "graph_edges",
+    "temporal_events",
+]
+
+# Retained for the migration log's drift hash and as documentation of intent.
+# apply() below is the authoritative, idempotent executor.
+DDL = ";".join(
+    [f"ALTER TABLE {t} ADD COLUMN scope TEXT NOT NULL DEFAULT 'personal'" for t in TABLES]
+    + [f"ALTER TABLE {t} ADD COLUMN shared_with TEXT" for t in TABLES]
+    + [f"CREATE INDEX IF NOT EXISTS idx_{t}_scope ON {t}(scope)" for t in TABLES]
+    + [
+        f"CREATE INDEX IF NOT EXISTS idx_{t}_profile_scope ON {t}(profile_id, scope)"
+        for t in TABLES
+    ]
+)
+
+
+def _table_exists(conn: sqlite3.Connection, table: str) -> bool:
+    return conn.execute(
+        "SELECT 1 FROM sqlite_master WHERE type='table' AND name=?", (table,)
+    ).fetchone() is not None
+
+
+def _column_names(conn: sqlite3.Connection, table: str) -> set[str]:
+    return {r[1] for r in conn.execute(f"PRAGMA table_info({table})").fetchall()}
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Idempotently add scope/shared_with columns + indexes to every core table.
+
+    Per table: skip if the table doesn't exist yet; add each column only if
+    missing (SQLite has no ADD COLUMN IF NOT EXISTS); create indexes with
+    IF NOT EXISTS. Safe to run on fresh installs (columns already present),
+    upgrades (columns missing), and partial/repeat applies.
+    """
+    for t in TABLES:
+        if not _table_exists(conn, t):
+            continue
+        cols = _column_names(conn, t)
+        if "scope" not in cols:
+            conn.execute(
+                f"ALTER TABLE {t} ADD COLUMN scope TEXT NOT NULL DEFAULT 'personal'"
+            )
+        if "shared_with" not in cols:
+            conn.execute(f"ALTER TABLE {t} ADD COLUMN shared_with TEXT")
+        conn.execute(f"CREATE INDEX IF NOT EXISTS idx_{t}_scope ON {t}(scope)")
+        conn.execute(
+            f"CREATE INDEX IF NOT EXISTS idx_{t}_profile_scope ON {t}(profile_id, scope)"
+        )
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Applied only when atomic_facts has the scope column AND its scope index.
+
+    Checking the index (not just the column) ensures apply() still runs on a
+    fresh install where create_all_tables created the column but not the index.
+    """
+    # v3.6.15: verify EVERY core table apply() touches — not just atomic_facts.
+    # A partial apply (scope added to atomic_facts but not the other tables) must
+    # NOT false-pass, or M016 is marked done and the remaining tables are left
+    # permanently without the scope column. Absent tables are skipped, matching
+    # apply()'s own skip-missing-table contract.
+    for t in TABLES:
+        try:
+            info = conn.execute(f"PRAGMA table_info({t})").fetchall()
+        except sqlite3.Error:
+            return False
+        if not info:
+            continue  # table absent on this DB — apply() skips it too
+        cols = {r[1] for r in info}
+        if "scope" not in cols:
+            return False
+        idx = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='index' AND name=?",
+            (f"idx_{t}_scope",),
+        ).fetchone()
+        if idx is None:
+            return False
+    return True

package/src/superlocalmemory/storage/models.py

@@ -119,6 +119,8 @@ class MemoryRecord:
 
     memory_id: str = field(default_factory=_new_id)
     profile_id: str = "default"
+    scope: str = "personal"
+    shared_with: list[str] | None = None
     content: str = ""
     session_id: str = ""
     speaker: str = ""              # Who said this
@@ -139,6 +141,8 @@ class AtomicFact:
     fact_id: str = field(default_factory=_new_id)
     memory_id: str = ""            # Source memory this was extracted from
     profile_id: str = "default"
+    scope: str = "personal"
+    shared_with: list[str] | None = None
     content: str = ""              # Atomic fact statement
     fact_type: FactType = FactType.SEMANTIC
 
@@ -193,6 +197,8 @@ class CanonicalEntity:
 
     entity_id: str = field(default_factory=_new_id)
     profile_id: str = "default"
+    scope: str = "personal"
+    shared_with: list[str] | None = None
     canonical_name: str = ""
     entity_type: str = ""          # person / place / org / concept / event
     first_seen: str = field(default_factory=_now)
@@ -251,6 +257,8 @@ class TemporalEvent:
 
     event_id: str = field(default_factory=_new_id)
     profile_id: str = "default"
+    scope: str = "personal"
+    shared_with: list[str] | None = None
     entity_id: str = ""            # FK to CanonicalEntity
     fact_id: str = ""              # FK to AtomicFact
     observation_date: str | None = None
@@ -266,6 +274,8 @@ class GraphEdge:
 
     edge_id: str = field(default_factory=_new_id)
     profile_id: str = "default"
+    scope: str = "personal"
+    shared_with: list[str] | None = None
     source_id: str = ""            # Fact ID or Entity ID
     target_id: str = ""            # Fact ID or Entity ID
     edge_type: EdgeType = EdgeType.ENTITY