superlocalmemory 3.7.8 → 3.8.1

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

@@ -0,0 +1,137 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""M029 — profile-scoped indexes for large behavioral histories.
+
+Dashboard reads always filter behavioral and outcome history by profile before
+sorting or aggregating. These composite indexes keep those operations bounded
+to one tenant as the shared database grows.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M029_behavioral_history_indexes"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_outcome_time
+    ON action_outcomes(profile_id, outcome, timestamp DESC);
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_time
+    ON action_outcomes(profile_id, settled, settled_at DESC);
+CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_cursor
+    ON action_outcomes(
+        profile_id, settled, COALESCE(settled_at, ''), outcome_id
+    );
+CREATE INDEX IF NOT EXISTS idx_assertions_profile_confidence
+    ON behavioral_assertions(profile_id, confidence DESC);
+CREATE INDEX IF NOT EXISTS idx_tool_events_profile_created
+    ON tool_events(profile_id, created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_soft_prompts_profile_active_category
+    ON soft_prompt_templates(profile_id, active, category, prompt_id);
+"""
+
+_INDEXES: tuple[tuple[str, str, tuple[str, ...]], ...] = (
+    (
+        "idx_outcomes_profile_outcome_time",
+        "action_outcomes",
+        ("profile_id", "outcome", "timestamp"),
+    ),
+    (
+        "idx_outcomes_profile_settled_time",
+        "action_outcomes",
+        ("profile_id", "settled", "settled_at"),
+    ),
+    (
+        "idx_outcomes_profile_settled_cursor",
+        "action_outcomes",
+        ("profile_id", "settled", "settled_at", "outcome_id"),
+    ),
+    (
+        "idx_assertions_profile_confidence",
+        "behavioral_assertions",
+        ("profile_id", "confidence"),
+    ),
+    (
+        "idx_tool_events_profile_created",
+        "tool_events",
+        ("profile_id", "created_at"),
+    ),
+    (
+        "idx_soft_prompts_profile_active_category",
+        "soft_prompt_templates",
+        ("profile_id", "active", "category", "prompt_id"),
+    ),
+)
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    return {
+        str(row[1])
+        for row in conn.execute(f"PRAGMA table_info({table})").fetchall()
+    }
+
+
+def _index_sql(name: str) -> str:
+    statements = {
+        "idx_outcomes_profile_outcome_time": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_outcome_time "
+            "ON action_outcomes(profile_id, outcome, timestamp DESC)"
+        ),
+        "idx_outcomes_profile_settled_time": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_time "
+            "ON action_outcomes(profile_id, settled, settled_at DESC)"
+        ),
+        "idx_outcomes_profile_settled_cursor": (
+            "CREATE INDEX IF NOT EXISTS idx_outcomes_profile_settled_cursor "
+            "ON action_outcomes("
+            "profile_id, settled, COALESCE(settled_at, ''), outcome_id)"
+        ),
+        "idx_assertions_profile_confidence": (
+            "CREATE INDEX IF NOT EXISTS idx_assertions_profile_confidence "
+            "ON behavioral_assertions(profile_id, confidence DESC)"
+        ),
+        "idx_tool_events_profile_created": (
+            "CREATE INDEX IF NOT EXISTS idx_tool_events_profile_created "
+            "ON tool_events(profile_id, created_at DESC)"
+        ),
+        "idx_soft_prompts_profile_active_category": (
+            "CREATE INDEX IF NOT EXISTS "
+            "idx_soft_prompts_profile_active_category "
+            "ON soft_prompt_templates(profile_id, active, category, prompt_id)"
+        ),
+    }
+    return statements[name]
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Add each index supported by the installed runtime schema.
+
+    Optional v3.2/v3.4.7 tables also declare these indexes in their owning
+    schema modules, so a partial bootstrap cannot permanently miss an index
+    when those tables are created later.
+    """
+    for name, table, required_columns in _INDEXES:
+        if set(required_columns) <= _columns(conn, table):
+            conn.execute(_index_sql(name))
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Require each index whose backing table and columns are present."""
+    names = {
+        str(row[0])
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='index'"
+        ).fetchall()
+    }
+    return all(
+        name in names
+        for name, table, required_columns in _INDEXES
+        if set(required_columns) <= _columns(conn, table)
+    )
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Create only indexes supported by the current optional schema."""
+    apply(conn)

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

@@ -0,0 +1,93 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+
+"""M030 — page-first Entity Explorer indexes for large installations."""
+
+from __future__ import annotations
+
+import sqlite3
+
+NAME = "M030_entity_explorer_indexes"
+DB_TARGET = "memory"
+
+DDL = """
+CREATE INDEX IF NOT EXISTS idx_entities_profile_fact_count_id
+    ON canonical_entities(profile_id, fact_count DESC, entity_id ASC);
+CREATE INDEX IF NOT EXISTS idx_entities_profile_type_fact_count_id
+    ON canonical_entities(
+        profile_id, entity_type COLLATE NOCASE, fact_count DESC, entity_id ASC
+    );
+CREATE INDEX IF NOT EXISTS idx_entity_profiles_profile_entity_rank
+    ON entity_profiles(
+        profile_id, entity_id, last_compiled_at DESC,
+        project_name COLLATE NOCASE
+    );
+"""
+
+_INDEXES: tuple[tuple[str, str, tuple[str, ...], str], ...] = (
+    (
+        "idx_entities_profile_fact_count_id",
+        "canonical_entities",
+        ("profile_id", "fact_count", "entity_id"),
+        "CREATE INDEX IF NOT EXISTS idx_entities_profile_fact_count_id "
+        "ON canonical_entities(profile_id, fact_count DESC, entity_id ASC)",
+    ),
+    (
+        "idx_entities_profile_type_fact_count_id",
+        "canonical_entities",
+        ("profile_id", "entity_type", "fact_count", "entity_id"),
+        "CREATE INDEX IF NOT EXISTS idx_entities_profile_type_fact_count_id "
+        "ON canonical_entities("
+        "profile_id, entity_type COLLATE NOCASE, fact_count DESC, entity_id ASC"
+        ")",
+    ),
+    (
+        "idx_entity_profiles_profile_entity_rank",
+        "entity_profiles",
+        (
+            "profile_id",
+            "entity_id",
+            "last_compiled_at",
+            "project_name",
+        ),
+        "CREATE INDEX IF NOT EXISTS idx_entity_profiles_profile_entity_rank "
+        "ON entity_profiles("
+        "profile_id, entity_id, last_compiled_at DESC, "
+        "project_name COLLATE NOCASE"
+        ")",
+    ),
+)
+
+
+def _columns(conn: sqlite3.Connection, table: str) -> set[str]:
+    return {
+        str(row[1])
+        for row in conn.execute(f"PRAGMA table_info({table})").fetchall()
+    }
+
+
+def apply(conn: sqlite3.Connection) -> None:
+    """Create every index supported by the installed optional schema."""
+    for _, table, required_columns, sql in _INDEXES:
+        if set(required_columns) <= _columns(conn, table):
+            conn.execute(sql)
+
+
+def verify(conn: sqlite3.Connection) -> bool:
+    """Require indexes only when their complete backing schema exists."""
+    names = {
+        str(row[0])
+        for row in conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='index'"
+        ).fetchall()
+    }
+    return all(
+        name in names
+        for name, table, required_columns, _ in _INDEXES
+        if set(required_columns) <= _columns(conn, table)
+    )
+
+
+def repair(conn: sqlite3.Connection) -> None:
+    """Safely restore a dropped index without replaying data migrations."""
+    apply(conn)

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

@@ -26,6 +26,8 @@ from . import (
     M015_add_pinned_column,
     M019_derivation_lineage,
     M020_model_state_integrity,
+    M029_behavioral_history_indexes,
+    M030_entity_explorer_indexes,
 )
 
 # ---------------------------------------------------------------------------
@@ -77,6 +79,8 @@ __all__ = (
     "M015_add_pinned_column",
     "M019_derivation_lineage",
     "M020_model_state_integrity",
+    "M029_behavioral_history_indexes",
+    "M030_entity_explorer_indexes",
     # Legacy re-exports (backward compat):
     "CURRENT_SCHEMA_VERSION",
     "get_schema_version",

package/src/superlocalmemory/storage/models.py

@@ -440,3 +440,7 @@ class RecallResponse:
     # be mistaken for a reranked response.
     reranker_applied: bool = False
     reranker_status: str = "not_configured"
+    # Wave Q2b: precomputed community summary for the cluster the top results
+    # fall into (thematic context). None unless results cluster into one
+    # community above threshold. Additive — backward compatible.
+    community_context: dict | None = None

package/src/superlocalmemory/storage/schema.py

@@ -38,6 +38,8 @@ _TABLES: Final[tuple[str, ...]] = (
     "memories",
     "atomic_facts",
     "canonical_entities",
+    "fact_entity_associations",
+    "fact_entity_association_repair_state",
     "entity_aliases",
     "entity_profiles",
     "memory_scenes",
@@ -52,10 +54,14 @@ _TABLES: Final[tuple[str, ...]] = (
     "compliance_audit",
     "bm25_tokens",
     "config",
+    "entity_communities",
+    "community_summaries",
+    "persona_summary",
 )
 
 _FTS_TABLES: Final[tuple[str, ...]] = (
     "atomic_facts_fts",
+    "fact_expansion_fts",
 )
 
 
@@ -281,6 +287,24 @@ END;
 """
 
 
+# ---------------------------------------------------------------------------
+# Fact expansion FTS (Phase 4, T3b — fact-augmented key expansion)
+# ---------------------------------------------------------------------------
+# Standalone (NOT external-content) FTS5 holding per-fact alternate keys
+# (entity aliases + paraphrases). Kept separate from atomic_facts_fts so the
+# proven content index and its triggers are never touched. Populated by
+# core.key_expander on store (and backfilled), queried as an additive UNION in
+# the BM25 channel. fact_id is stored so results can be scope-JOINed to
+# atomic_facts.
+_SQL_FACT_EXPANSION_FTS: Final[str] = """
+CREATE VIRTUAL TABLE IF NOT EXISTS fact_expansion_fts
+    USING fts5(
+        fact_id UNINDEXED,
+        alt_keys
+    );
+"""
+
+
 # ---------------------------------------------------------------------------
 # Canonical entities
 # ---------------------------------------------------------------------------
@@ -306,7 +330,52 @@ CREATE INDEX IF NOT EXISTS idx_entities_profile
 CREATE INDEX IF NOT EXISTS idx_entities_name_lower
     ON canonical_entities (profile_id, canonical_name COLLATE NOCASE);
 CREATE INDEX IF NOT EXISTS idx_entities_type
-    ON canonical_entities (profile_id, entity_type);"""
+    ON canonical_entities (profile_id, entity_type);
+CREATE INDEX IF NOT EXISTS idx_entities_profile_fact_count
+    ON canonical_entities (profile_id, fact_count DESC);
+CREATE INDEX IF NOT EXISTS idx_entities_profile_type_fact_count
+    ON canonical_entities (
+        profile_id, entity_type COLLATE NOCASE, fact_count DESC
+    );"""
+
+
+# ---------------------------------------------------------------------------
+# Normalized fact/entity associations (also the ingestion effect ledger)
+# ---------------------------------------------------------------------------
+
+_SQL_FACT_ENTITY_ASSOCIATIONS: Final[str] = """
+CREATE TABLE IF NOT EXISTS fact_entity_associations (
+    profile_id TEXT NOT NULL,
+    fact_id TEXT NOT NULL,
+    entity_id TEXT NOT NULL,
+    first_operation_id TEXT NOT NULL DEFAULT '',
+    count_applied INTEGER NOT NULL DEFAULT 0
+        CHECK (count_applied IN (0, 1)),
+    created_at TEXT NOT NULL DEFAULT (
+        strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+    ),
+    PRIMARY KEY (profile_id, fact_id, entity_id),
+    FOREIGN KEY (fact_id) REFERENCES atomic_facts(fact_id) ON DELETE CASCADE,
+    FOREIGN KEY (entity_id)
+        REFERENCES canonical_entities(entity_id) ON DELETE CASCADE
+);
+CREATE INDEX IF NOT EXISTS idx_fact_entity_associations_entity
+    ON fact_entity_associations(profile_id, entity_id, fact_id);
+CREATE TABLE IF NOT EXISTS fact_entity_association_repair_state (
+    repair_key TEXT PRIMARY KEY,
+    state TEXT NOT NULL DEFAULT 'pending'
+        CHECK (state IN ('pending', 'running', 'retrying', 'complete')),
+    target_fact_rowid INTEGER NOT NULL DEFAULT -1,
+    last_fact_rowid INTEGER NOT NULL DEFAULT 0,
+    scanned INTEGER NOT NULL DEFAULT 0,
+    inserted INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT NOT NULL DEFAULT '',
+    updated_at TEXT NOT NULL
+);
+INSERT OR IGNORE INTO fact_entity_association_repair_state
+    (repair_key, state, target_fact_rowid, updated_at)
+VALUES ('historical-backfill', 'pending', -1, '');
+"""
 
 
 # ---------------------------------------------------------------------------
@@ -316,6 +385,7 @@ CREATE INDEX IF NOT EXISTS idx_entities_type
 _SQL_ENTITY_ALIASES: Final[str] = """
 CREATE TABLE IF NOT EXISTS entity_aliases (
     alias_id    TEXT PRIMARY KEY,
+    profile_id  TEXT NOT NULL DEFAULT 'default',
     entity_id   TEXT NOT NULL,
     alias       TEXT NOT NULL,
     confidence  REAL NOT NULL DEFAULT 1.0,
@@ -329,6 +399,10 @@ CREATE INDEX IF NOT EXISTS idx_aliases_entity
     ON entity_aliases (entity_id);
 CREATE INDEX IF NOT EXISTS idx_aliases_lookup
     ON entity_aliases (alias COLLATE NOCASE);
+-- NOTE: the (profile_id, entity_id) index is created by migration M022, NOT
+-- here. On an upgrading DB this DDL runs at engine init BEFORE the deferred
+-- M022 adds the profile_id column, so referencing it here would fail engine
+-- init with "no such column: profile_id".
 """
 
 
@@ -663,6 +737,58 @@ CREATE TABLE IF NOT EXISTS config (
 );
 """
 
+# Wave Q: entity-community backbone (additive; safe on existing DBs).
+# One row per (profile, entity) mapping to the community it belongs to,
+# computed by Louvain over the entity co-occurrence graph in the background.
+# Shared spine for Q2 community summaries and Q3 progressive abstraction.
+_SQL_ENTITY_COMMUNITIES: Final[str] = """
+CREATE TABLE IF NOT EXISTS entity_communities (
+    profile_id  TEXT    NOT NULL,
+    entity_id   TEXT    NOT NULL,
+    community_id INTEGER NOT NULL,
+    computed_at TEXT    NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (profile_id, entity_id)
+);
+CREATE INDEX IF NOT EXISTS idx_entity_comm_profile
+    ON entity_communities(profile_id);
+CREATE INDEX IF NOT EXISTS idx_entity_comm_cid
+    ON entity_communities(profile_id, community_id);
+"""
+
+# Wave Q2: one synthesized report per entity community (additive; safe on
+# existing DBs). Generated in the background after entity_communities; the
+# summary excludes superseded facts. member_fact_ids enables drill-down.
+_SQL_COMMUNITY_SUMMARIES: Final[str] = """
+CREATE TABLE IF NOT EXISTS community_summaries (
+    profile_id      TEXT    NOT NULL,
+    community_id    INTEGER NOT NULL,
+    summary         TEXT    NOT NULL DEFAULT '',
+    keywords        TEXT    NOT NULL DEFAULT '',
+    entity_ids_json TEXT    NOT NULL DEFAULT '[]',
+    fact_ids_json   TEXT    NOT NULL DEFAULT '[]',
+    fact_count      INTEGER NOT NULL DEFAULT 0,
+    computed_at     TEXT    NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (profile_id, community_id)
+);
+CREATE INDEX IF NOT EXISTS idx_comm_summ_profile
+    ON community_summaries(profile_id);
+"""
+
+# Wave Q3: progressive-abstraction top tier — one persona roll-up per profile
+# consuming the top community summaries (additive; safe on existing DBs).
+# Recall-gated (never auto-injected into hot recall) and size-bounded to avoid
+# the V3.4.40 summary-pollution regression. Drill-down: community_ids_json →
+# communities → their member facts.
+_SQL_PERSONA_SUMMARY: Final[str] = """
+CREATE TABLE IF NOT EXISTS persona_summary (
+    profile_id         TEXT PRIMARY KEY,
+    summary            TEXT NOT NULL DEFAULT '',
+    keywords           TEXT NOT NULL DEFAULT '',
+    community_ids_json TEXT NOT NULL DEFAULT '[]',
+    computed_at        TEXT NOT NULL DEFAULT (datetime('now'))
+);
+"""
+
 # ---------------------------------------------------------------------------
 # Ordered DDL list (tables before FTS, respects FK order)
 # ---------------------------------------------------------------------------
@@ -673,6 +799,7 @@ _DDL_ORDERED: Final[tuple[str, ...]] = (
     _SQL_MEMORIES,
     _SQL_ATOMIC_FACTS,
     _SQL_CANONICAL_ENTITIES,
+    _SQL_FACT_ENTITY_ASSOCIATIONS,
     _SQL_ENTITY_ALIASES,
     _SQL_ENTITY_PROFILES,
     _SQL_MEMORY_SCENES,
@@ -691,6 +818,14 @@ _DDL_ORDERED: Final[tuple[str, ...]] = (
     _SQL_V2_MIGRATION_CLEANUP,
     # FTS5 must come after atomic_facts (content table) AND after cleanup
     _SQL_ATOMIC_FACTS_FTS,
+    # T3b: standalone expansion FTS (additive; safe on existing DBs)
+    _SQL_FACT_EXPANSION_FTS,
+    # Wave Q: entity-community backbone (additive; safe on existing DBs)
+    _SQL_ENTITY_COMMUNITIES,
+    # Wave Q2: community summaries (additive; safe on existing DBs)
+    _SQL_COMMUNITY_SUMMARIES,
+    # Wave Q3: persona roll-up tier (additive; safe on existing DBs)
+    _SQL_PERSONA_SUMMARY,
 )
 
 

package/src/superlocalmemory/storage/schema_v32.py

@@ -359,6 +359,8 @@ V32_DDL: list[str] = [
         ON soft_prompt_templates(profile_id, active);
     CREATE INDEX IF NOT EXISTS idx_soft_prompt_category
         ON soft_prompt_templates(profile_id, category);
+    CREATE INDEX IF NOT EXISTS idx_soft_prompts_profile_active_category
+        ON soft_prompt_templates(profile_id, active, category, prompt_id);
     CREATE UNIQUE INDEX IF NOT EXISTS idx_soft_prompt_unique_cat
         ON soft_prompt_templates(profile_id, category)
         WHERE active = 1;

package/src/superlocalmemory/storage/schema_v343.py

@@ -43,7 +43,7 @@ V343_TABLES: Final[tuple[str, ...]] = (
 # ---------------------------------------------------------------------------
 
 _MESH_DDL = """
--- Mesh Peers
+-- Mesh Peers  (profile_id = tenant boundary; see M023)
 CREATE TABLE IF NOT EXISTS mesh_peers (
     peer_id TEXT PRIMARY KEY,
     session_id TEXT NOT NULL,
@@ -52,7 +52,8 @@ CREATE TABLE IF NOT EXISTS mesh_peers (
     host TEXT DEFAULT '127.0.0.1',
     port INTEGER DEFAULT 0,
     registered_at TEXT NOT NULL,
-    last_heartbeat TEXT NOT NULL
+    last_heartbeat TEXT NOT NULL,
+    profile_id TEXT NOT NULL DEFAULT 'default'
 );
 
 -- Mesh Messages
@@ -63,23 +64,28 @@ CREATE TABLE IF NOT EXISTS mesh_messages (
     msg_type TEXT DEFAULT 'text',
     content TEXT NOT NULL,
     read INTEGER DEFAULT 0,
-    created_at TEXT NOT NULL
+    created_at TEXT NOT NULL,
+    profile_id TEXT NOT NULL DEFAULT 'default'
 );
 
--- Mesh State (shared key-value store)
+-- Mesh State (shared key-value store, per tenant)
 CREATE TABLE IF NOT EXISTS mesh_state (
-    key TEXT PRIMARY KEY,
+    profile_id TEXT NOT NULL DEFAULT 'default',
+    key TEXT NOT NULL,
     value TEXT NOT NULL,
     set_by TEXT NOT NULL,
-    updated_at TEXT NOT NULL
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (profile_id, key)
 );
 
--- Mesh Locks (file-level locks for coordination)
+-- Mesh Locks (file-level locks for coordination, per tenant)
 CREATE TABLE IF NOT EXISTS mesh_locks (
-    file_path TEXT PRIMARY KEY,
+    profile_id TEXT NOT NULL DEFAULT 'default',
+    file_path TEXT NOT NULL,
     locked_by TEXT NOT NULL,
     locked_at TEXT NOT NULL,
-    expires_at TEXT NOT NULL DEFAULT '9999-12-31T23:59:59Z'
+    expires_at TEXT NOT NULL DEFAULT '9999-12-31T23:59:59Z',
+    PRIMARY KEY (profile_id, file_path)
 );
 
 -- Mesh Events (audit log)
@@ -88,9 +94,14 @@ CREATE TABLE IF NOT EXISTS mesh_events (
     event_type TEXT NOT NULL,
     payload TEXT DEFAULT '{}',
     emitted_by TEXT NOT NULL,
-    created_at TEXT NOT NULL
+    created_at TEXT NOT NULL,
+    profile_id TEXT NOT NULL DEFAULT 'default'
 );
 
+-- NOTE: profile-leading indexes live in migration M023, never here — on an
+-- upgrade the profile_id column does not exist when this DDL runs (the old
+-- table already exists, so CREATE TABLE IF NOT EXISTS no-ops), and a
+-- CREATE INDEX on the missing column would abort engine init.
 CREATE INDEX IF NOT EXISTS idx_mesh_messages_to
     ON mesh_messages(to_peer, read);
 CREATE INDEX IF NOT EXISTS idx_mesh_events_type
@@ -123,16 +134,17 @@ CREATE INDEX IF NOT EXISTS idx_entity_profiles_project
 _INGESTION_DDL = """
 CREATE TABLE IF NOT EXISTS ingestion_log (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
+    profile_id TEXT NOT NULL DEFAULT 'default',
     source_type TEXT NOT NULL,
     dedup_key TEXT NOT NULL,
     fact_ids TEXT DEFAULT '[]',
     metadata TEXT DEFAULT '{}',
     status TEXT DEFAULT 'ingested',
     ingested_at TEXT NOT NULL,
-    UNIQUE(source_type, dedup_key)
+    UNIQUE(profile_id, source_type, dedup_key)
 );
 CREATE INDEX IF NOT EXISTS idx_ingestion_dedup
-    ON ingestion_log(source_type, dedup_key);
+    ON ingestion_log(profile_id, source_type, dedup_key);
 """
 
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/storage/schema_v347.py

@@ -48,6 +48,8 @@ CREATE INDEX IF NOT EXISTS idx_tool_events_session
     ON tool_events(session_id);
 CREATE INDEX IF NOT EXISTS idx_tool_events_project
     ON tool_events(project_path);
+CREATE INDEX IF NOT EXISTS idx_tool_events_profile_created
+    ON tool_events(profile_id, created_at DESC);
 """
 
 # ---------------------------------------------------------------------------
@@ -80,6 +82,8 @@ CREATE INDEX IF NOT EXISTS idx_assertions_project
     ON behavioral_assertions(project_path, profile_id);
 CREATE INDEX IF NOT EXISTS idx_assertions_category
     ON behavioral_assertions(category);
+CREATE INDEX IF NOT EXISTS idx_assertions_profile_confidence
+    ON behavioral_assertions(profile_id, confidence DESC);
 """
 
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/trust/gate.py

@@ -13,6 +13,7 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 from __future__ import annotations
 
 import logging
+import os
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -21,6 +22,26 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _env_threshold(name: str, default: float) -> float:
+    """Read a [0,1] threshold from the environment, falling back on parse/range error."""
+    try:
+        value = float(os.environ.get(name, ""))
+    except (TypeError, ValueError):
+        return default
+    return value if 0.0 <= value <= 1.0 else default
+
+
+# M-02/M-03 (3.7.9): thresholds are operator-tunable so multi-agent deployments
+# can tighten the write gate and opt into a read gate. Defaults are unchanged —
+# the audit's "raise write_threshold to 0.7" would block every new agent (a new
+# agent scores 0.5, Beta(1,1)); loopback callers bypass the gate entirely, so
+# this only affects remote credentialed agents. Read gate is OFF by default.
+_DEFAULT_WRITE_THRESHOLD = _env_threshold("SLM_TRUST_WRITE_THRESHOLD", 0.3)
+_DEFAULT_DELETE_THRESHOLD = _env_threshold("SLM_TRUST_DELETE_THRESHOLD", 0.5)
+_DEFAULT_READ_THRESHOLD = _env_threshold("SLM_TRUST_READ_THRESHOLD", 0.1)
+_READ_GATE_ENABLED = os.environ.get("SLM_TRUST_READ_GATE") == "1"
+
+
 class TrustError(PermissionError):
     """Raised when an agent fails a trust check.
 
@@ -62,17 +83,23 @@ class TrustGate:
     def __init__(
         self,
         scorer: TrustScorer,
-        write_threshold: float = 0.3,
-        delete_threshold: float = 0.5,
+        write_threshold: float = _DEFAULT_WRITE_THRESHOLD,
+        delete_threshold: float = _DEFAULT_DELETE_THRESHOLD,
+        read_threshold: float = _DEFAULT_READ_THRESHOLD,
+        read_gate_enabled: bool = _READ_GATE_ENABLED,
     ) -> None:
         if write_threshold < 0 or write_threshold > 1:
             raise ValueError("write_threshold must be in [0, 1]")
         if delete_threshold < 0 or delete_threshold > 1:
             raise ValueError("delete_threshold must be in [0, 1]")
+        if read_threshold < 0 or read_threshold > 1:
+            raise ValueError("read_threshold must be in [0, 1]")
 
         self._scorer = scorer
         self._write_threshold = write_threshold
         self._delete_threshold = delete_threshold
+        self._read_threshold = read_threshold
+        self._read_gate_enabled = read_gate_enabled
 
     @property
     def write_threshold(self) -> float:
@@ -116,15 +143,29 @@ class TrustGate:
                 agent_id, score, self._delete_threshold, "delete"
             )
 
+    @property
+    def read_threshold(self) -> float:
+        return self._read_threshold
+
+    @property
+    def read_gate_enabled(self) -> bool:
+        return self._read_gate_enabled
+
     def check_read(self, agent_id: str, profile_id: str) -> None:
-        """Read check — always passes. Logged for audit trail.
+        """Read check. Passes by default; logged for the audit trail.
 
-        Reads are never blocked because denying read access could break
-        agent functionality. However, logging read access enables
-        anomaly detection and compliance auditing.
+        M-03 (3.7.9): reads are unblocked by default because denying read access
+        could break agent functionality. Operators who need to stop a
+        compromised agent from exfiltrating the store can set
+        ``SLM_TRUST_READ_GATE=1`` (optionally with ``SLM_TRUST_READ_THRESHOLD``)
+        to enforce a minimum trust for reads too.
         """
         score = self._scorer.get_agent_trust(agent_id, profile_id)
         logger.debug(
-            "trust gate read (always pass): agent=%s trust=%.3f",
-            agent_id, score,
+            "trust gate read: agent=%s trust=%.3f gate=%s",
+            agent_id, score, self._read_gate_enabled,
         )
+        if self._read_gate_enabled and score < self._read_threshold:
+            raise TrustError(
+                agent_id, score, self._read_threshold, "read"
+            )