superlocalmemory 3.4.49 → 3.4.52

package/CHANGELOG.md

@@ -5,6 +5,65 @@ All notable changes to SuperLocalMemory V3 will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.4.52] - 2026-05-28 — Warm Memory, No Cold Starts
+
+**Production resilience for session_init.** No quality degradation as the primary path: full 6-channel recall (semantic + BM25 + entity + temporal + Hopfield + spreading-activation, Fisher-Rao fusion) is preserved. The cold-start problem is fixed at the infrastructure layer, not by downgrading retrieval.
+
+### Fixed
+- **Ollama embedding model unloads after 5 min idle** (`core/ollama_embedder.py`) — `_call_ollama_embed` and `_call_ollama_embed_batch` did not pass `keep_alive` to Ollama, so the embedder defaulted to 5-minute residency. After idle, next call required a 20-30s model reload from disk → DaemonPoolProxy's 30s HTTP timeout occasionally aborted → MCP clients (Hermes, CommandCode) saw `session init failed (connection error)`. Now both calls pass `keep_alive: -1`, pinning `nomic-embed-text` (~274 MB) in VRAM forever. Industry-standard pattern used by Hindsight, Zep, Supermemory.
+- **DaemonPoolProxy HTTP timeout increased 30s → 60s** (`mcp/_daemon_proxy.py`) — Safety net for unexpected slowness during daemon restart windows. With keep_alive=-1 in place, this almost never matters, but it removes the cliff edge.
+
+### Added
+- **Emergency FTS5 BM25 fallback in `session_init`** (`mcp/tools_active.py`) — When the daemon is completely unreachable (truly dead, not just slow), `session_init` falls back to a direct SQLite query against the existing `atomic_facts_fts` virtual table with native BM25 ranking via `ORDER BY fts.rank`. Multi-process safe via WAL mode. Response includes explicit `degraded_mode: true` and `retrieval_mode: "emergency_fts5_bm25"` flags (Zep "Memory Unavailable" pattern) so agents can surface the degraded state to the user. This is the Mem0 / Letta industry-standard fallback — real BM25 math, not keyword LIKE.
+- **`/health` reports `embedding_warm` flag** (`server/unified_daemon.py`) — MCP clients can poll the daemon's health endpoint to wait for the embedding model to finish loading before issuing recall calls. Set to `true` once the async pre-warm thread completes its first `embedder.embed("warmup")` call.
+
+### Changed
+- **`session_init` reverted to full 6-channel recall** (`mcp/tools_active.py`) — v3.4.51 had downgraded `session_init` to `fast=True` (BM25 only) as a timeout workaround. v3.4.52 restores full 6-channel recall as the primary path — quality is no longer compromised. Cold-start is prevented at the Ollama layer instead.
+
+### Why this matters
+A memory system's value is its retrieval quality. Degrading to BM25-only at session start would mean every agent session begins with degraded memory — exactly the opposite of what users expect. v3.4.52 fixes the actual root cause (Ollama cold-start) and reserves the BM25 fallback for true catastrophic failures (daemon completely dead). The agent is told explicitly via `degraded_mode` when this happens.
+
+## [3.4.51] - 2026-05-28 — Recency Intelligence
+
+**Session context is now time-aware.** Stale memories from completed projects and old debugging sessions no longer surface at session start. Frequently-recalled architectural decisions resist decay automatically.
+
+### Fixed
+- **Exponential recency decay + FSRS stability strengthening** (`retrieval/engine.py`) — Replaced the nearly-flat linear formula (range `[0.92×, 1.1×]`, 2.3% spread) with an Ebbinghaus exponential decay enhanced by FSRS v5 access-count stabilization. Formula: `boost = 0.8 + 0.3 × e^(-(ln2/S) × age_days)` where `S = 30d × min(2.0, 1 + 0.1 × access_count)`. Effect: a 45-day-old session handoff recalled 0 times → 0.91× (was 1.075×). Same memory recalled 10 times → 0.95× — frequently-used architectural decisions naturally resist decay without any category labeling. Reference: Dae & Jarrett (2024) FSRS v5; Ebbinghaus (1885) retention curve.
+- **`age_days` hardcoded to 0 in adaptive ranker** (`core/recall_pipeline.py`) — Both `apply_adaptive_ranking` and `apply_v2_adaptive_ranking` were passing `"age_days": 0` to the LightGBM ranker, making it permanently blind to memory age. Now computes real age from `fact.created_at`. The ranker can now learn age-preference signals.
+- **`created_at` missing from pool recall protocol** (`server/unified_daemon.py`, `mcp/_pool_adapter.py`) — The daemon's `/recall` response omitted `created_at`. Added to both recall response serialisation paths and to `PoolFact` dataclass. All MCP-layer tools now receive real memory timestamps.
+- **`session_init` age gate** (`mcp/tools_active.py`) — Added `max_age_days: int = 30` parameter. Memories older than 30 days are suppressed unless their relevance score ≥ 0.70 (architectural decisions always surface). `max_age_days=0` disables the gate. Removed `fast=True` — session context deserves full 6-channel recall.
+- **`slm session-context` age gate** (`cli/commands.py`) — Fast-path SQLite query now respects `--max-age-days` (default: 30). Previously hardcoded to 7 days. CLI and MCP now apply identical age semantics.
+
+### Added
+- **`slm session-context --max-age-days N`** (`cli/main.py`) — New flag to control how far back session context reaches. Default 30. Set to 0 to disable. Consistent with MCP `session_init(max_age_days=N)`.
+- **`slm session-context --full`** — Explicit flag to use the full engine path (was implicit via code). Documented.
+- **`slm session-context --json`** — Agent-native JSON output, consistent with all other commands.
+
+### Changed
+- `session_init` MCP tool schema gains optional `max_age_days` parameter (default: 30). Backward-compatible.
+- `PoolFact` gains `created_at: str = ""` field. Backward-compatible — defaults to empty string.
+- `slm session-context` fast path changed from hardcoded 7-day window to `--max-age-days` controlled window (default 30).
+
+## [3.4.50] - 2026-05-25 — Scale-Ready
+
+**1 million memories. Zero slowdown.** Tiered storage, graph pruning, and optional acceleration backends for infinite scale.
+
+### Added
+- **Tiered Storage (Hot/Warm/Cold/Archive)** — Facts auto-classified by age + access patterns. Hot facts prioritized in graph/vector search. Cold facts archived but never deleted. Nightly rebalance with misfire-safe cron. `slm pin <fact_id>` to keep any fact hot forever.
+- **Graph Pruning Engine** — Chain collapse, garbage entity removal, low-activity edge decay. Reduced edge count while preserving semantic connections. Safe to run repeatedly — idempotent.
+- **access_count_30d** — Rolling 30-day access window with batch-flush recording. Replaces lifetime counter for accurate tier assignment (F-14).
+- **Optional Graph Acceleration** — `pip install superlocalmemory[cozo]` for CozoDB embedded graph backend. Replaces NetworkX for spreading activation at 1M+ edges. Zero-config: daemon auto-migrates on restart.
+- **Optional Vector Acceleration** — `pip install superlocalmemory[lancedb]` for LanceDB embedded vector backend. Cosine similarity with IVF+PQ indexing. Auto-migration from sqlite-vec.
+- **Backend Status Dashboard** — `slm doctor` shows CozoDB/LanceDB migration status, tier distribution, and health warnings.
+- **M014_v345_scale_ready migration** — Automatic on daemon restart. Adds `access_count_30d` column and graph edge indexes.
+
+### Changed
+- **Migration is fully automatic.** Upgrade package → restart daemon → done. No `slm migrate` needed. Schema applied silently via the migration runner. Idempotent — safe to restart multiple times.
+
+### Fixed
+- **WAL lock contention** — Multiple stale `slm mcp` processes causing 16-second health checks. Process reaper enhanced with orphan detection.
+- **Graph edge index performance** — Added `idx_graph_edges_source_id` and `idx_graph_edges_target_id` for bulk import at 1M+ scale (F-20).
+
 ## [3.4.49] - 2026-05-22
 
 ### Added

package/README.md

@@ -4,7 +4,7 @@
 
 <h1 align="center">SuperLocalMemory V3.4</h1>
 <p align="center"><strong>Every other AI forgets. Yours won't.</strong><br/><em>Infinite memory for Claude Code, Cursor, Windsurf, and any MCP-compatible AI client.</em></p>
-<p align="center"><code>v3.4.48</code> — Install once. Every session remembers the last. Automatically.<br><strong>Now with multi-machine agent mesh — M4 and M5 coordinate as one.</strong></p>
+<p align="center"><code>v3.4.51 "Recency Intelligence"</code> — <strong>Session context is now time-aware.</strong><br>Stale memories from old projects no longer surface. Ebbinghaus decay + FSRS stability. One command: <code>pip install -U superlocalmemory && slm restart</code></p>
 <p align="center"><strong>Backed by 3 published research papers</strong> (arXiv preprints + Zenodo-archived) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 
 <p align="center">
@@ -183,6 +183,30 @@ slm warmup    # Pre-download embedding model (~500MB, optional)
 pip install superlocalmemory
 ```
 
+### Upgrading to v3.4.5 "Scale-Ready"
+
+**Migration is automatic.** Upgrade your package, restart the daemon, and your database migrates silently.
+
+```bash
+# pip users
+pip install -U superlocalmemory
+slm restart
+
+# npm users  
+npm update -g superlocalmemory
+slm restart
+
+# Verify migration
+slm doctor
+```
+
+No manual commands. No data loss. Your database upgrades in-place with zero downtime. The daemon auto-detects the old version and applies the migration on first start.
+
+**New capabilities after upgrade:**
+- Tiered storage: memories auto-classified as active/warm/cold/archived
+- Graph pruning: redundant edges removed, queries stay fast at 1M+ connections
+- Optional: `pip install superlocalmemory[cozo,lancedb]` for graph + vector acceleration
+
 ### First Use
 
 ```bash
@@ -410,6 +434,23 @@ Every recall generates learning signals. Over time, the system adapts to your pa
 
 Auto-capture hooks: `slm hooks install` + `slm observe` + `slm session-context`. MCP tools: `session_init`, `observe`, `report_feedback`.
 
+**`session_init` MCP parameters:**
+| Parameter | Type | Default | Description |
+|---|---|---|---|
+| `project_path` | string | `""` | Working directory — used to derive search query |
+| `query` | string | `""` | Override search query |
+| `max_results` | int | `10` | Max memories to return |
+| `max_age_days` | int | `30` | Suppress memories older than N days (0 = disabled). Memories with score ≥ 0.70 always surface regardless of age. |
+
+**`slm session-context` CLI flags** (consistent with MCP):
+```bash
+slm session-context                          # fast path, 30-day window (default)
+slm session-context --max-age-days 7         # only last 7 days
+slm session-context --max-age-days 0         # no age filter
+slm session-context "my query" --full        # full engine path (slow, requires Ollama)
+slm session-context --json                   # agent-native JSON output
+```
+
 **No competitor learns at zero token cost.**
 
 </details>
@@ -548,6 +589,7 @@ All 8 mesh tools work seamlessly across machines:
 | `slm hooks install` | Wire auto-memory into Claude Code hooks |
 | `slm profile list/create/switch` | Profile management |
 | `slm decay` | Run memory lifecycle review |
+| `slm session-context [query]` | Print session context (for hooks). Flags: `--max-age-days N` (default 30), `--full`, `--json` |
 | `slm quantize` | Run smart compression cycle |
 | `slm consolidate --cognitive` | Extract patterns from memory clusters |
 | `slm soft-prompts` | View auto-learned patterns |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.49",
+  "version": "3.4.52",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.49"
+version = "3.4.52"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.46"
+__version__ = "3.4.52"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/commands.py

@@ -2147,12 +2147,17 @@ def cmd_session_context(args: Namespace) -> None:
         except sqlite3.OperationalError:
             pass
 
-        # 2. Recent important memories (last 7 days, top 10 by importance)
+        # 2. Recent important memories — age gate from --max-age-days (default 30)
+        max_age = getattr(args, "max_age_days", 30)
+        age_clause = (
+            f"AND created_at >= datetime('now', '-{int(max_age)} days') "
+            if max_age > 0 else ""
+        )
         try:
             rows = conn.execute(
                 "SELECT content, fact_type, created_at FROM atomic_facts "
                 "WHERE profile_id = ? "
-                "AND created_at >= datetime('now', '-7 days') "
+                f"{age_clause}"
                 "AND lifecycle = 'active' "
                 "ORDER BY importance DESC, created_at DESC LIMIT 10",
                 (pid,),

package/src/superlocalmemory/cli/main.py

@@ -289,6 +289,16 @@ def main() -> None:
 
     ctx_p = sub.add_parser("session-context", help="Print session context (for hooks)")
     ctx_p.add_argument("query", nargs="?", default="", help="Optional context query")
+    ctx_p.add_argument(
+        "--max-age-days", type=int, default=30,
+        help="Suppress memories older than N days unless score ≥ 0.7 (default: 30). "
+             "Set 0 to disable age filter.",
+    )
+    ctx_p.add_argument(
+        "--full", action="store_true",
+        help="Use full engine path (slower, requires Ollama). Default is fast SQLite path.",
+    )
+    ctx_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     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/core/backend_orchestrator.py

@@ -0,0 +1,365 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""SuperLocalMemory v3.4.5 — Backend Orchestrator.
+
+Central coordinator for multi-backend architecture.
+Manages CozoDB, LanceDB, and TierManager lifecycle.
+Handles auto-migration, fallback, and incremental sync.
+
+This is the ONLY module that imports all three backends.
+Other modules call BackendOrchestrator methods.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.storage.database import DatabaseManager
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Global singleton (set by daemon, read by store_pipeline)
+# ---------------------------------------------------------------------------
+
+_orchestrator: BackendOrchestrator | None = None
+
+
+def get_orchestrator() -> BackendOrchestrator | None:
+    """Return the global BackendOrchestrator singleton."""
+    return _orchestrator
+
+
+def set_orchestrator(orch: BackendOrchestrator) -> None:
+    """Set the global BackendOrchestrator singleton."""
+    global _orchestrator
+    _orchestrator = orch
+
+
+# ---------------------------------------------------------------------------
+# BackendOrchestrator
+# ---------------------------------------------------------------------------
+
+class BackendOrchestrator:
+    """Central coordinator for multi-backend architecture.
+
+    Lifecycle:
+      on_daemon_start() → migrate backends → ready
+      sync_new_fact() → called from store_pipeline after SQLite write
+      health_check() → returns status of all backends
+    """
+
+    def __init__(self, config: SLMConfig, db: DatabaseManager) -> None:
+        self._config = config
+        self._db = db
+        self._data_dir = Path(config.data_dir)
+        self._cozo: Any = None
+        self._lancedb: Any = None
+        self._tiers: Any = None
+        self._backend_cache: dict[str, str] = {}
+
+    # ------------------------------------------------------------------
+    # Daemon Startup
+    # ------------------------------------------------------------------
+
+    def on_daemon_start(self) -> None:
+        """Called once on daemon startup. Order matters (F-11: rebalance before migration)."""
+        logger.info("BackendOrchestrator: daemon starting")
+
+        # 1. Apply schema (if not already applied)
+        self._apply_schema_v345()
+
+        # 2. Initialize TierManager (always)
+        try:
+            from superlocalmemory.core.tier_manager import evaluate_tiers, set_backends
+            self._tiers = evaluate_tiers
+            set_backends(cozo=self._cozo, lancedb=self._lancedb)
+            logger.info("BackendOrchestrator: TierManager initialized")
+        except Exception as exc:
+            logger.warning("TierManager init failed (non-fatal): %s", exc)
+
+        # 3. Run initial tier rebalance FIRST (F-11: before migration)
+        try:
+            from superlocalmemory.core.tier_manager import evaluate_tiers as rebalance
+            result = rebalance(self._db)
+            logger.info("BackendOrchestrator: initial rebalance — %s",
+                         result.get("total_evaluated", "?"))
+        except Exception as exc:
+            logger.warning("Initial rebalance failed (non-fatal): %s", exc)
+
+        # 4. Initialize CozoDB if available
+        cozo_available = self._detect_cozo()
+        if cozo_available:
+            self._init_cozo()
+
+        # 5. Initialize LanceDB if available
+        lancedb_available = self._detect_lancedb()
+        if lancedb_available:
+            self._init_lancedb()
+
+        # 6. Auto-migrate
+        if self._cozo:
+            status = self._cozo_status()
+            if status in ("not_initialized", "migrating"):
+                if status == "migrating":
+                    logger.warning("CozoDB migration interrupted — rebuilding")
+                self._migrate_cozo()
+
+        if self._lancedb:
+            status = self._lancedb_status()
+            if status in ("not_initialized", "migrating"):
+                if status == "migrating":
+                    logger.warning("LanceDB migration interrupted — rebuilding")
+                self._migrate_lancedb()
+
+        logger.info("BackendOrchestrator: daemon ready (cozo=%s, lancedb=%s)",
+                     "active" if self._cozo and self._cozo_status() == "active" else "off",
+                     "active" if self._lancedb and self._lancedb_status() == "active" else "off")
+
+    # ------------------------------------------------------------------
+    # Incremental Sync (F-04: called from store_pipeline)
+    # ------------------------------------------------------------------
+
+    def sync_new_fact(self, fact: Any) -> None:
+        """Sync a newly stored fact to CozoDB and LanceDB.
+
+        Called AFTER SQLite write in store_pipeline.
+        Non-blocking, best-effort. Failures are logged, not raised.
+        """
+        try:
+            tier = getattr(fact, "lifecycle", "active")
+        except Exception:
+            tier = "active"
+
+        if tier in ("active", "warm"):
+            if self._cozo and self._cozo_status() == "active":
+                self._sync_fact_entities(fact)
+
+            if self._lancedb and self._lancedb_status() == "active":
+                self._sync_fact_embedding(fact)
+
+    def _sync_fact_entities(self, fact: Any) -> None:
+        """Sync fact's entities and edges to CozoDB."""
+        try:
+            entities = getattr(fact, "canonical_entities", []) or []
+            for eid in entities:
+                self._cozo.add_entity(eid, eid, "concept", {})
+                # Add edges from this entity to existing ones
+                for other in entities:
+                    if other != eid:
+                        self._cozo.add_edge(eid, other, "co_occurs", 1.0)
+        except Exception as exc:
+            logger.debug("CozoDB incremental sync skipped: %s", exc)
+
+    def _sync_fact_embedding(self, fact: Any) -> None:
+        """Sync fact's embedding to LanceDB."""
+        try:
+            embedding = getattr(fact, "embedding", None)
+            if embedding:
+                tier = getattr(fact, "lifecycle", "active")
+                self._lancedb.add_vectors(
+                    [fact.fact_id], [embedding], [tier],
+                )
+        except Exception as exc:
+            logger.debug("LanceDB incremental sync skipped: %s", exc)
+
+    # ------------------------------------------------------------------
+    # Backend Access
+    # ------------------------------------------------------------------
+
+    def get_graph_backend(self) -> Any:
+        """Return active graph backend or None (caller falls back to NetworkX)."""
+        if self._cozo and self._cozo_status() == "active":
+            return self._cozo
+        return None
+
+    def get_vector_backend(self) -> Any:
+        """Return active vector backend or None."""
+        if self._lancedb and self._lancedb_status() == "active":
+            return self._lancedb
+        return None
+
+    # ------------------------------------------------------------------
+    # Health Check
+    # ------------------------------------------------------------------
+
+    def health_check(self) -> dict[str, Any]:
+        """Comprehensive health status for dashboard + CLI."""
+        result: dict[str, Any] = {
+            "sqlite": {"status": "active"},
+            "cozo": {"status": "not_available"},
+            "lancedb": {"status": "not_available"},
+            "tiers": {},
+            "warnings": [],
+        }
+
+        try:
+            from superlocalmemory.core.tier_manager import get_tier_stats
+            result["tiers"] = get_tier_stats(self._db)
+        except Exception:
+            pass
+
+        if self._cozo:
+            try:
+                result["cozo"] = self._cozo.health_check()
+            except Exception as exc:
+                result["cozo"] = {"status": "error", "error": str(exc)}
+        else:
+            result["warnings"].append(
+                "CozoDB not active. Install: pip install superlocalmemory[cozo]"
+            )
+
+        if self._lancedb:
+            try:
+                result["lancedb"] = self._lancedb.health_check()
+            except Exception as exc:
+                result["lancedb"] = {"status": "error", "error": str(exc)}
+        else:
+            result["warnings"].append(
+                "LanceDB not active. Install: pip install superlocalmemory[lancedb]"
+            )
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Internal: Detection
+    # ------------------------------------------------------------------
+
+    def _detect_cozo(self) -> bool:
+        if self._config.get("graph_backend") == "sqlite":
+            return False
+        try:
+            import pycozo  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    def _detect_lancedb(self) -> bool:
+        if self._config.get("vector_backend") == "sqlite-vec":
+            return False
+        try:
+            import lancedb  # noqa: F401
+            return True
+        except ImportError:
+            return False
+
+    # ------------------------------------------------------------------
+    # Internal: Init
+    # ------------------------------------------------------------------
+
+    def _init_cozo(self) -> None:
+        try:
+            from superlocalmemory.graph.cozo_backend import CozoDBGraphBackend
+            cozo_path = self._data_dir / "cozo"
+            cozo_path.mkdir(parents=True, exist_ok=True)
+            self._cozo = CozoDBGraphBackend(str(cozo_path / "graph"))
+            self._update_status("cozo", "not_initialized")
+            logger.info("CozoDB initialized at %s", cozo_path)
+        except Exception as exc:
+            logger.warning("CozoDB init failed: %s", exc)
+            self._cozo = None
+
+    def _init_lancedb(self) -> None:
+        try:
+            from superlocalmemory.vector.lancedb_backend import LanceDBVectorBackend
+            lance_path = self._data_dir / "lance"
+            self._lancedb = LanceDBVectorBackend(str(lance_path))
+            self._update_status("lancedb", "not_initialized")
+            logger.info("LanceDB initialized at %s", lance_path)
+        except Exception as exc:
+            logger.warning("LanceDB init failed: %s", exc)
+            self._lancedb = None
+
+    # ------------------------------------------------------------------
+    # Internal: Migration
+    # ------------------------------------------------------------------
+
+    def _migrate_cozo(self) -> None:
+        self._update_status("cozo", "migrating")
+
+        def _run():
+            conn = sqlite3.connect(str(self._data_dir / "memory.db"))
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA query_only=ON")  # F-07: read-only in migration thread
+            try:
+                count = self._cozo.bulk_import_from_sqlite(conn)
+                self._update_status("cozo", "active", count)
+                logger.info("CozoDB migration complete: %d edges", count)
+            except Exception as exc:
+                logger.error("CozoDB migration failed: %s", exc)
+                self._update_status("cozo", "failed", error=str(exc))
+            finally:
+                conn.close()
+
+        threading.Thread(target=_run, daemon=True).start()
+
+    def _migrate_lancedb(self) -> None:
+        self._update_status("lancedb", "migrating")
+
+        def _run():
+            conn = sqlite3.connect(str(self._data_dir / "memory.db"))
+            conn.execute("PRAGMA journal_mode=WAL")
+            conn.execute("PRAGMA query_only=ON")
+            try:
+                count = self._lancedb.bulk_import_from_sqlite(conn)
+                self._update_status("lancedb", "active", count)
+                logger.info("LanceDB migration complete: %d vectors", count)
+            except Exception as exc:
+                logger.error("LanceDB migration failed: %s", exc)
+                self._update_status("lancedb", "failed", error=str(exc))
+            finally:
+                conn.close()
+
+        threading.Thread(target=_run, daemon=True).start()
+
+    # ------------------------------------------------------------------
+    # Internal: Status
+    # ------------------------------------------------------------------
+
+    def _cozo_status(self) -> str:
+        return self._backend_cache.get("cozo", "not_initialized")
+
+    def _lancedb_status(self) -> str:
+        return self._backend_cache.get("lancedb", "not_initialized")
+
+    def _update_status(self, name: str, status: str,
+                        count: int = 0, error: str = "") -> None:
+        self._backend_cache[name] = status
+        try:
+            self._db.conn.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
+
+    # ------------------------------------------------------------------
+    # Internal: Schema
+    # ------------------------------------------------------------------
+
+    def _apply_schema_v345(self) -> None:
+        try:
+            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"])
+        except ImportError:
+            logger.debug("schema_v345 not found — skipping")
+        except Exception as exc:
+            logger.warning("Schema v3.4.5 apply failed (non-fatal): %s", exc)

package/src/superlocalmemory/core/ollama_embedder.py

@@ -204,12 +204,18 @@ class OllamaEmbedder:
             return False
 
     def _call_ollama_embed(self, text: str) -> list[float]:
-        """Call Ollama embed endpoint for a single text."""
+        """Call Ollama embed endpoint for a single text.
+
+        v3.4.52: ``keep_alive: -1`` pins the embedding model in VRAM
+        forever so subsequent calls have no cold-start latency. Industry
+        pattern (Hindsight, Zep, Supermemory) — without this, Ollama
+        unloads after 5min idle and the next call takes 20-30s.
+        """
         import httpx
 
         resp = httpx.post(
             f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": [text]},
+            json={"model": self._model, "input": [text], "keep_alive": -1},
             timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
         )
         resp.raise_for_status()
@@ -219,12 +225,16 @@ class OllamaEmbedder:
         return self._normalize(vec)
 
     def _call_ollama_embed_batch(self, texts: list[str]) -> list[list[float] | None]:
-        """Call Ollama embed endpoint with batch input."""
+        """Call Ollama embed endpoint with batch input.
+
+        v3.4.52: ``keep_alive: -1`` pins the embedding model — see
+        ``_call_ollama_embed`` docstring for rationale.
+        """
         import httpx
 
         resp = httpx.post(
             f"{self._base_url}/api/embed",
-            json={"model": self._model, "input": texts},
+            json={"model": self._model, "input": texts, "keep_alive": -1},
             timeout=httpx.Timeout(_RESPONSE_TIMEOUT, connect=_CONNECT_TIMEOUT),
         )
         resp.raise_for_status()