superlocalmemory 3.8.0 → 3.8.2

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/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",
@@ -328,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, '');
+"""
 
 
 # ---------------------------------------------------------------------------
@@ -752,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,

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_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/ui/index.html

@@ -182,7 +182,6 @@
                   <div class="value num" id="k-clu">—</div>
                   <div class="delta" id="k-clu-delta">&nbsp;</div>
                   <div class="spark" id="sp-clu"></div>
-                  <!-- TODO: endpoint /api/v3/clusters/count does not exist yet -->
                 </div>
               </section>
 
@@ -192,8 +191,8 @@
                 <!-- memory growth + quick actions -->
                 <div class="card">
                   <div class="card-head">
-                    <h3>Memory growth</h3>
-                    <span class="sub">facts stored over time</span>
+                    <h3>Memory activity</h3>
+                    <span class="sub">facts added by day · past year</span>
                     <div class="spacer"></div>
                   </div>
                   <div class="card-pad">
@@ -300,9 +299,7 @@
                 <div class="card">
                   <div class="card-head"><h3>Where memories come from</h3></div>
                   <div class="card-pad">
-                    <!-- populated by loadDashboardSources() in dashboard.js -->
-                    <!-- TODO: endpoint /api/v3/ingestion/sources does not exist yet;
-                         showing static breakdown from /api/stats for now -->
+                    <!-- populated by loadDashboardSources() from profile-scoped provenance -->
                     <div id="src">
                       <div class="muted" style="padding:16px;text-align:center;font-size:13px">Loading...</div>
                     </div>
@@ -1569,7 +1566,8 @@
     <!-- OD screen modules (v3.7.9): approved-design panes wired to live data.
          Load LAST so their window.load<Screen> overrides win over the legacy loaders. -->
     <script src="static/js/od-brain.js?v=379"></script>
-    <script src="static/js/od-health.js?v=380"></script>
+    <script src="static/js/od-components.js?v=382"></script>
+    <script src="static/js/od-health.js?v=382"></script>
     <script src="static/js/od-operations.js?v=380"></script>
     <script src="static/js/od-team.js?v=379"></script>
     <script src="static/js/od-graph.js?v=379"></script>
@@ -1580,7 +1578,7 @@
     <script src="static/js/od-skills.js?v=379"></script>
     <script src="static/js/od-mesh.js?v=379"></script>
     <script src="static/js/od-optimize.js?v=379"></script>
-    <script src="static/js/od-settings.js?v=380"></script>
+    <script src="static/js/od-settings.js?v=382"></script>
     <script src="static/js/od-backup.js?v=379"></script>
     <!-- MCP & Integrations pane (v3.8.0): shows exposed MCP tool profile + counts -->
     <script src="static/js/od-mcp.js?v=380"></script>

package/src/superlocalmemory/ui/js/core.js

@@ -35,11 +35,11 @@ window.slmInstallToken = (function () {
     };
 })();
 
-// Global fetch patch: apply the abort timeout to every relative-URL request
+// Global fetch patch: apply the abort timeout to every same-origin request
 // automatically. 17 UI modules call bare fetch() — patching here avoids
 // touching each one and guarantees no future callsite can regress to an
-// un-timed fetch that holds the spinner forever. Absolute URLs (external
-// resources) are passed through unchanged. Callers that already supply
+// un-timed fetch that holds the spinner forever. External URLs are passed
+// through unchanged. Callers that already supply
 // `signal` keep their own behavior. `init.timeoutMs` lets callers override
 // the default per-request.
 (function patchFetch() {
@@ -49,25 +49,68 @@ window.slmInstallToken = (function () {
     window.__slmOriginalFetch = _origFetch;
     window.fetch = function (input, init) {
         init = Object.assign({}, init || {});
-        var urlStr = typeof input === 'string' ? input : (input && input.url) || '';
-        var isRelative = !(/^https?:\/\//i.test(urlStr));
+        var urlStr = typeof input === 'string'
+            ? input
+            : (input && (input.url || input.href)) || '';
+        // Resolve every URL before deciding whether it is local. In particular,
+        // protocol-relative URLs such as //host/path inherit the current scheme
+        // but are not same-origin and must never receive the install token.
+        var isSameOrigin = false;
+        var requestUrl = null;
+        try {
+            requestUrl = new URL(urlStr, window.location.href);
+            isSameOrigin = requestUrl.origin === window.location.origin;
+        } catch (e) {
+            // A malformed URL is handled by native fetch. Treat it as external
+            // here so it cannot obtain local credentials while failing.
+        }
         var method = String(
             init.method || (input && input.method) || 'GET'
         ).toUpperCase();
         var mutating = ['POST', 'PUT', 'PATCH', 'DELETE'].indexOf(method) !== -1;
+        var invalidatesCache = init.slmInvalidatesCache !== false;
+        var requiresWriteAuth = init.slmRequiresWriteAuth !== false;
+        delete init.slmInvalidatesCache;
+        delete init.slmRequiresWriteAuth;
+
+        function invalidateAfterMutation(request) {
+            if (!isSameOrigin || !mutating || !invalidatesCache) return request;
+            return request.then(function (response) {
+                if (
+                    response && response.ok &&
+                    typeof window.slmInvalidatePanes === 'function'
+                ) {
+                    window.slmInvalidatePanes();
+                }
+                if (
+                    response && response.ok &&
+                    typeof window.slmInvalidateDashboardCache === 'function'
+                ) {
+                    window.slmInvalidateDashboardCache();
+                }
+                return response;
+            });
+        }
 
         function send() {
-            if (!isRelative || init.signal) {
-                return _origFetch(input, init);
+            if (!isSameOrigin || init.signal) {
+                return invalidateAfterMutation(_origFetch(input, init));
             }
             var controller = new AbortController();
             var timeoutMs = init.timeoutMs || window.SLM_FETCH_TIMEOUT_MS;
             var timer = setTimeout(function () { controller.abort(); }, timeoutMs);
             init.signal = controller.signal;
-            return _origFetch(input, init).finally(function () { clearTimeout(timer); });
+            return invalidateAfterMutation(
+                _origFetch(input, init).finally(function () { clearTimeout(timer); })
+            );
         }
 
-        if (isRelative && mutating && urlStr !== '/internal/token') {
+        if (
+            isSameOrigin &&
+            mutating &&
+            requiresWriteAuth &&
+            (!requestUrl || requestUrl.pathname !== '/internal/token')
+        ) {
             return window.slmInstallToken(false).then(function (token) {
                 if (!token) throw new Error('local write credential unavailable');
                 var headers = new Headers(