superlocalmemory 3.7.7 → 3.8.0

package/src/superlocalmemory/core/config.py

@@ -236,6 +236,11 @@ class EncodingConfig:
     # Entropy gate
     entropy_threshold: float = 0.95
 
+    # Entity reflexion (Wave Q1) — Mode B/C self-review of extracted entities.
+    # Fail-open; one extra bounded LLM call per chunk. Mode A is unaffected.
+    enable_entity_reflexion: bool = True
+    reflexion_max_facts: int = 8
+
 
 # ---------------------------------------------------------------------------
 # Retrieval Config
@@ -297,6 +302,11 @@ class RetrievalConfig:
     recall_per_fact_max_chars: int = 2400  # ~600 tokens; head 70% + tail 30%
     recall_total_max_chars: int = 12000    # ~3K tokens; stubs beyond this
 
+    # Wave Q2b: attach a precomputed community summary as thematic context when
+    # the top results cluster in one community. Read-only lookup, gated, and
+    # fail-open — never a per-query LLM call. Kill-switch for tuning.
+    enable_community_context: bool = True
+
 
 # ---------------------------------------------------------------------------
 # Math Config
@@ -659,6 +669,14 @@ class TemporalValidatorConfig:
     # Sheaf contradiction threshold
     contradiction_threshold: float = 0.45        # Mode A threshold (768d)
 
+    # P5-INT-01: superseded facts are DEMOTED in recall, not hidden. A fact
+    # marked system_expired_at keeps its channel evidence but its per-channel
+    # score is multiplied by this factor, so current facts rank above it while
+    # nothing valid silently vanishes (Mem0-2026 non-destructive design;
+    # retrieval-time recency resolves conflicts). 0.0 restores the old hide
+    # behaviour; 1.0 disables demotion.
+    superseded_demotion_factor: float = 0.25
+
     # LLM pre-filter threshold (lower to catch more candidates)
     llm_prefilter_threshold: float = 0.30
 
@@ -677,18 +695,31 @@ class EvolutionConfig:
     """Configuration for Skill Evolution Engine (v3.4.10).
 
     OFF by default — opt in via `slm setup` (interactive) or
-    `slm config set evolution.enabled true` (CLI).
+    `slm config set evolution.enabled true` (CLI). Enabling makes
+    background LLM calls; the enable flow surfaces a cost advisory.
 
     Backend auto-detection priority:
       1. `claude` CLI available → spawn `claude --model haiku` (ECC pattern, free)
       2. Ollama running → use Ollama (free, local)
       3. API key set → use Anthropic/OpenAI API (paid)
       4. Nothing → dashboard-only (show candidates, manual evolution)
+
+    Model selection (v3.7.9): each pipeline step is configurable and
+    defaults to the lowest-cost capable model for the active backend
+    (Claude→haiku, Ollama→local). Leave a field empty ("") for "auto".
+    The blind verifier is kept on a *different* model from the generator
+    so it can't grade its own homework; see
+    ``evolution.model_selection.resolve_evolution_models``.
     """
 
     enabled: bool = False                        # OFF by default, opt-in
     backend: str = "auto"                        # auto, claude, ollama, anthropic, openai
     max_evolutions_per_cycle: int = 3            # Budget cap per consolidation
+    # Empty string == "auto" (resolve cheapest capable model at runtime).
+    # Accepts short aliases ("haiku"/"sonnet") or allow-listed model ids.
+    mutation_model: str = ""                     # generator (quality-sensitive)
+    verify_model: str = ""                       # blind verifier (must differ from generator)
+    confirm_model: str = ""                      # cheap yes/no gate
 
 
 @dataclass(frozen=True)
@@ -743,6 +774,152 @@ class AutoInvokeConfig:
     relevance_threshold: float = 0.3           # Legacy compat with AutoRecall
 
 
+# ---------------------------------------------------------------------------
+# Deployment Config (v3.8.0)
+# ---------------------------------------------------------------------------
+
+_VALID_DEPLOYMENT_MODES = ("personal", "enterprise")
+
+
+@dataclass(frozen=True)
+class DeploymentConfig:
+    """Deployment mode configuration.
+
+    Personal (default, safe defaults):
+        Single-user install. No login required, no PII redaction, no
+        retention scheduler. Behaviour is identical to pre-3.8.0 installs.
+
+    Enterprise:
+        Multi-user / team / company install. Login required, PII redacted,
+        retention scheduler active, audit enabled.
+
+    SAFE DEFAULTS = Personal — an existing config.toml with no [deployment]
+    section continues to behave exactly as before.  Adding a [deployment]
+    section is opt-in; removing it reverts to Personal automatically.
+    """
+
+    mode: str = "personal"          # "personal" | "enterprise"
+    require_login: bool = False
+    pii_redaction: bool = False
+    retention_enabled: bool = False
+    audit: bool = True
+
+    def __post_init__(self) -> None:
+        if self.mode not in _VALID_DEPLOYMENT_MODES:
+            raise ValueError(
+                f"DeploymentConfig.mode must be one of {_VALID_DEPLOYMENT_MODES!r}, "
+                f"got {self.mode!r}"
+            )
+
+    @property
+    def is_personal(self) -> bool:
+        """True when operating in personal (single-user) mode."""
+        return self.mode == "personal"
+
+    @property
+    def is_enterprise(self) -> bool:
+        """True when operating in enterprise (team/company) mode."""
+        return self.mode == "enterprise"
+
+    def as_dict(self) -> dict:
+        return {
+            "mode": self.mode,
+            "require_login": self.require_login,
+            "pii_redaction": self.pii_redaction,
+            "retention_enabled": self.retention_enabled,
+            "audit": self.audit,
+        }
+
+
+#: Canonical Personal preset — all permissive defaults.
+DEPLOYMENT_PERSONAL = DeploymentConfig(
+    mode="personal",
+    require_login=False,
+    pii_redaction=False,
+    retention_enabled=False,
+    audit=True,
+)
+
+#: Canonical Enterprise preset — all enforcement defaults.
+DEPLOYMENT_ENTERPRISE = DeploymentConfig(
+    mode="enterprise",
+    require_login=True,
+    pii_redaction=True,
+    retention_enabled=True,
+    audit=True,
+)
+
+
+def load_deployment_config(
+    config_toml_path: Path | None = None,
+) -> DeploymentConfig:
+    """Parse [deployment] from config.toml; return Personal defaults if absent.
+
+    config.toml is the installer-written performance config (separate from the
+    daemon's config.json managed by SLMConfig). This function reads ONLY the
+    [deployment] section. All other sections are ignored.
+
+    Args:
+        config_toml_path: Explicit path to config.toml. When None, resolved to
+            ``~/.superlocalmemory/config.toml`` via the canonical data root.
+
+    Returns:
+        DeploymentConfig — Personal preset when the file is absent, the section
+        is missing, or any parse error occurs (fail-open, non-destructive).
+    """
+    if config_toml_path is None:
+        try:
+            config_toml_path = _runtime_base_dir() / "config.toml"
+        except Exception:
+            return DEPLOYMENT_PERSONAL
+
+    if not config_toml_path.exists():
+        return DEPLOYMENT_PERSONAL
+
+    try:
+        import tomllib as _tomllib
+        raw = config_toml_path.read_text(encoding="utf-8")
+        data = _tomllib.loads(raw)
+    except Exception as exc:
+        logger.warning(
+            "load_deployment_config: failed to parse %s: %s", config_toml_path, exc
+        )
+        return DEPLOYMENT_PERSONAL
+
+    dep = data.get("deployment", {})
+    if not dep:
+        # No [deployment] section — personal defaults, no behaviour change.
+        return DEPLOYMENT_PERSONAL
+
+    raw_mode = str(dep.get("mode", "personal")).lower()
+    if raw_mode not in _VALID_DEPLOYMENT_MODES:
+        logger.warning(
+            "load_deployment_config: unknown mode %r in %s — defaulting to personal",
+            raw_mode, config_toml_path,
+        )
+        raw_mode = "personal"
+
+    # Use the preset for the mode as the base so omitted keys inherit
+    # sensible values (enterprise → require_login=True etc.).
+    base = DEPLOYMENT_ENTERPRISE if raw_mode == "enterprise" else DEPLOYMENT_PERSONAL
+
+    try:
+        return DeploymentConfig(
+            mode=raw_mode,
+            require_login=bool(dep.get("require_login", base.require_login)),
+            pii_redaction=bool(dep.get("pii_redaction", base.pii_redaction)),
+            retention_enabled=bool(dep.get("retention_enabled", base.retention_enabled)),
+            audit=bool(dep.get("audit", base.audit)),
+        )
+    except (ValueError, TypeError) as exc:
+        logger.warning(
+            "load_deployment_config: invalid values in [deployment] in %s: %s — "
+            "falling back to personal",
+            config_toml_path, exc,
+        )
+        return DEPLOYMENT_PERSONAL
+
+
 # ---------------------------------------------------------------------------
 # Health Config (v3.6.9 BUG-A)
 # ---------------------------------------------------------------------------
@@ -849,6 +1026,35 @@ class SLMConfig:
         path = config_path or (_runtime_base / "config.json")
         if not path.exists():
             return cls.for_mode(Mode.A, base_dir=_runtime_base)
+
+        # DASH-V4 (3.7.9): the ``current_mode`` file is the single source of
+        # truth for the ACTIVE mode. If config.json drifted from it (a writer
+        # bypassed switch_mode and reset the active config), load the
+        # authoritative per-mode file so daemon/CLI/dashboard all run the user's
+        # chosen mode — with its settings — instead of a stale one. Scoped to
+        # config.json so explicit per-mode loads (switch_mode) are untouched.
+        # Fail-open: any error falls through to the normal load below.
+        if path.name == "config.json":
+            try:
+                import json as _json
+                _disk_mode = str(
+                    _json.loads(path.read_text()).get("mode", "")
+                ).lower()
+                _active_mode = cls.read_current_mode(path.parent)
+                if _disk_mode and _active_mode and _disk_mode != _active_mode:
+                    _mode_path = cls._mode_config_path(
+                        path.parent, Mode(_active_mode)
+                    )
+                    if _mode_path.exists():
+                        logger.warning(
+                            "config.json mode=%s disagrees with current_mode=%s;"
+                            " loading authoritative %s",
+                            _disk_mode, _active_mode, _mode_path.name,
+                        )
+                        return cls.load(_mode_path)
+            except Exception:
+                pass  # fail-open — fall through to the normal load below
+
         import json
         try:
             data = json.loads(path.read_text())
@@ -1070,6 +1276,9 @@ class SLMConfig:
             "enabled": self.evolution.enabled,
             "backend": self.evolution.backend,
             "max_evolutions_per_cycle": self.evolution.max_evolutions_per_cycle,
+            "mutation_model": self.evolution.mutation_model,
+            "verify_model": self.evolution.verify_model,
+            "confirm_model": self.evolution.confirm_model,
         }
 
         # V3.4.65: Persist injection config
@@ -1264,6 +1473,7 @@ class SLMConfig:
             _c_emb = EmbeddingConfig(
                 model_name=embedding_model_name or "text-embedding-3-large",
                 dimension=embedding_dimension or 3072,
+                provider=_c_emb_provider,
                 api_endpoint=embedding_endpoint,
                 api_key=embedding_key,
                 deployment_name=embedding_deployment,
@@ -1275,8 +1485,11 @@ class SLMConfig:
             # 768-dim Ollama embedder, which made ingestion fail at vector
             # materialization. Cloud embeddings remain an explicit opt-in.
             _c_emb = EmbeddingConfig(
-                model_name="nomic-ai/nomic-embed-text-v1.5",
-                dimension=768,
+                # Honour an on-disk embedding model when one was configured (the
+                # load() path passes it through); default to the local nomic
+                # model so Mode C never silently requires a paid cloud embedder.
+                model_name=embedding_model_name or "nomic-ai/nomic-embed-text-v1.5",
+                dimension=embedding_dimension or 768,
             )
         return cls(
             mode=mode,

package/src/superlocalmemory/core/consolidation_engine.py

@@ -49,6 +49,59 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+def _recompute_entity_communities(
+    db: Any, profile_id: str, summarizer: Any = None,
+) -> dict[str, int]:
+    """Wave Q: rebuild the entity-community backbone + summaries (fail-open).
+
+    Shared spine for Q2 community summaries and Q3 progressive abstraction.
+    Runs in the background consolidation lane; never blocks store/recall.
+    Community detection and summary generation are independently fail-open.
+    """
+    result: dict[str, int] = {"entity_count": 0, "community_count": 0}
+    try:
+        from superlocalmemory.core.entity_community import EntityCommunityBuilder
+
+        result = EntityCommunityBuilder(db).compute_and_store(profile_id)
+        logger.info(
+            "Background entity-community: %d entities, %d communities",
+            result.get("entity_count", 0),
+            result.get("community_count", 0),
+        )
+    except Exception as exc:
+        logger.debug("Entity-community recompute failed (non-fatal): %s", exc)
+        return result
+
+    # Wave Q2: one synthesized report per community (rides on the backbone).
+    try:
+        from superlocalmemory.core.community_summary import CommunitySummaryBuilder
+
+        summ = CommunitySummaryBuilder(db, summarizer=summarizer).compute_and_store(
+            profile_id,
+        )
+        result["summaries_written"] = summ.get("summaries_written", 0)
+        logger.info(
+            "Background community summaries: %d written",
+            summ.get("summaries_written", 0),
+        )
+    except Exception as exc:
+        logger.debug("Community summaries failed (non-fatal): %s", exc)
+
+    # Wave Q3: persona roll-up (top tier over the community summaries).
+    try:
+        from superlocalmemory.core.progressive_abstraction import (
+            ProgressiveAbstraction,
+        )
+
+        pa = ProgressiveAbstraction(db, summarizer=summarizer).compute_and_store(
+            profile_id,
+        )
+        result["persona_built"] = bool(pa.get("built", False))
+    except Exception as exc:
+        logger.debug("Persona roll-up failed (non-fatal): %s", exc)
+    return result
+
+
 class ConsolidationEngine:
     """Sleep-time memory consolidation with 6-step cycle.
 
@@ -254,21 +307,27 @@ class ConsolidationEngine:
         activation. Takes ~200-800ms, runs on daemon thread, zero impact
         on store/recall latency.
         """
-        if self._graph_analyzer is None:
-            return
         analyzer = self._graph_analyzer
         pid = profile_id
+        db = self._db
+        summarizer = self._summarizer
 
         def _run() -> None:
-            try:
-                result = analyzer.compute_and_store(pid)
-                logger.info(
-                    "Background graph analysis complete: %d nodes, %d communities",
-                    result.get("node_count", 0),
-                    result.get("community_count", 0),
-                )
-            except Exception as exc:
-                logger.debug("Background graph analysis failed (non-fatal): %s", exc)
+            if analyzer is not None:
+                try:
+                    result = analyzer.compute_and_store(pid)
+                    logger.info(
+                        "Background graph analysis complete: %d nodes, "
+                        "%d communities",
+                        result.get("node_count", 0),
+                        result.get("community_count", 0),
+                    )
+                except Exception as exc:
+                    logger.debug(
+                        "Background graph analysis failed (non-fatal): %s", exc,
+                    )
+            # Wave Q: entity-community backbone + summaries (Q2/Q3 spine).
+            _recompute_entity_communities(db, pid, summarizer)
 
         t = threading.Thread(target=_run, daemon=True, name="graph-analysis-bg")
         t.start()
@@ -510,15 +569,21 @@ class ConsolidationEngine:
                 fact_id, profile_id,
             )
 
-        # Fallback: direct SQL check
+        # Fallback: direct SQL check. Must consider BOTH valid_until (valid-time
+        # expiry) AND system_expired_at (transaction-time expiry) — a fact that
+        # was invalidated/erased sets system_expired_at, and ignoring it would
+        # let a GDPR-erased/superseded fact be promoted back into warm lifecycle.
         rows = self._db.execute(
-            "SELECT valid_until FROM fact_temporal_validity "
+            "SELECT valid_until, system_expired_at FROM fact_temporal_validity "
             "WHERE fact_id = ? AND profile_id = ?",
             (fact_id, profile_id),
         )
         if not rows:
             return True  # No temporal record = valid
-        valid_until = dict(rows[0]).get("valid_until")
+        row = dict(rows[0])
+        if row.get("system_expired_at") is not None:
+            return False  # transaction-time expired (invalidated/erased)
+        valid_until = row.get("valid_until")
         if valid_until is None:
             return True  # Open-ended validity
         try:
@@ -555,14 +620,22 @@ class ConsolidationEngine:
     def _step5_recompute_graph(
         self, profile_id: str,
     ) -> dict[str, Any]:
-        """Recompute PageRank + communities.  Delegates to GraphAnalyzer."""
-        if self._graph_analyzer is None:
-            return {"node_count": 0, "community_count": 0}
-        try:
-            return self._graph_analyzer.compute_and_store(profile_id)
-        except Exception as exc:
-            logger.warning("Graph recompute failed: %s", exc)
-            return {"node_count": 0, "community_count": 0}
+        """Recompute PageRank + communities.  Delegates to GraphAnalyzer.
+
+        Wave Q: also rebuilds the entity-community backbone (Q2/Q3 spine).
+        """
+        result: dict[str, Any] = {"node_count": 0, "community_count": 0}
+        if self._graph_analyzer is not None:
+            try:
+                result = self._graph_analyzer.compute_and_store(profile_id)
+            except Exception as exc:
+                logger.warning("Graph recompute failed: %s", exc)
+        ec = _recompute_entity_communities(
+            self._db, profile_id, self._summarizer,
+        )
+        result["entity_community_count"] = ec.get("community_count", 0)
+        result["community_summaries"] = ec.get("summaries_written", 0)
+        return result
 
     # ------------------------------------------------------------------
     # Step 6: Derive Associations

package/src/superlocalmemory/core/context_cache.py

@@ -65,6 +65,18 @@ class CacheEntry:
     provenance: str = "tool_observation"
     computed_at: int = 0
     byte_size: int = 0
+    profile_id: str = "default"
+
+
+def _active_profile_fallback(home: Path) -> str:
+    """Resolve the active profile for the cache reader hot path (stdlib only,
+    never raises). Two profiles can share a session_id, so cached context MUST
+    be keyed by profile or one tenant reads another's context."""
+    try:
+        raw = (home / "profiles.json").read_text(encoding="utf-8")
+        return json.loads(raw).get("active_profile", "default") or "default"
+    except Exception:
+        return "default"
 
 
 # ---------------------------------------------------------------------------
@@ -199,9 +211,24 @@ class ContextCache:
         return conn
 
     def _bootstrap_schema_and_meta(self) -> None:
+        # Isolation: cached context is keyed by profile so two tenants sharing a
+        # session_id cannot read each other's context. Older cache files lack
+        # the profile_id column — the cache is ephemeral (120s TTL), so drop and
+        # recreate rather than run a rebuild migration.
+        try:
+            cols = {
+                r[1] for r in self._write_conn.execute(
+                    "PRAGMA table_info(context_entries)"
+                ).fetchall()
+            }
+            if cols and "profile_id" not in cols:
+                self._write_conn.execute("DROP TABLE context_entries")
+        except sqlite3.Error:  # pragma: no cover — defensive
+            pass
         self._write_conn.executescript(
             """
             CREATE TABLE IF NOT EXISTS context_entries (
+                profile_id  TEXT NOT NULL DEFAULT 'default',
                 session_id  TEXT NOT NULL,
                 topic_sig   TEXT NOT NULL,
                 content     TEXT NOT NULL,
@@ -209,11 +236,11 @@ class ContextCache:
                 provenance  TEXT NOT NULL DEFAULT 'tool_observation',
                 computed_at INTEGER NOT NULL,
                 byte_size   INTEGER NOT NULL,
-                PRIMARY KEY (session_id, topic_sig)
+                PRIMARY KEY (profile_id, session_id, topic_sig)
             ) WITHOUT ROWID;
 
             CREATE INDEX IF NOT EXISTS idx_ctx_session_time
-                ON context_entries(session_id, computed_at);
+                ON context_entries(profile_id, session_id, computed_at);
             CREATE INDEX IF NOT EXISTS idx_ctx_time
                 ON context_entries(computed_at);
 
@@ -263,26 +290,38 @@ class ContextCache:
         self._write_conn.execute(
             """
             INSERT OR REPLACE INTO context_entries
-                (session_id, topic_sig, content, fact_ids,
+                (profile_id, session_id, topic_sig, content, fact_ids,
                  provenance, computed_at, byte_size)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
             """,
-            (entry.session_id, entry.topic_sig, content, fact_ids_json,
-             entry.provenance, computed_at, byte_size),
+            (entry.profile_id or "default", entry.session_id, entry.topic_sig,
+             content, fact_ids_json, entry.provenance, computed_at, byte_size),
         )
 
     # -- Cleanup ------------------------------------------------------------
 
     def cleanup_session(
         self, session_id: str, *, older_than: int = CLEANUP_HORIZON_SECONDS,
+        profile_id: str | None = None,
     ) -> int:
-        """Delete rows for ``session_id`` older than ``older_than`` seconds."""
+        """Delete rows for ``session_id`` older than ``older_than`` seconds.
+
+        When ``profile_id`` is given the delete is tenant-scoped so a cleanup on
+        a shared session_id cannot wipe another profile's cached context.
+        """
         cutoff = int(time.time()) - older_than
-        cur = self._write_conn.execute(
-            "DELETE FROM context_entries "
-            "WHERE session_id=? AND computed_at < ?",
-            (session_id, cutoff),
-        )
+        if profile_id is not None:
+            cur = self._write_conn.execute(
+                "DELETE FROM context_entries "
+                "WHERE profile_id=? AND session_id=? AND computed_at < ?",
+                (profile_id, session_id, cutoff),
+            )
+        else:
+            cur = self._write_conn.execute(
+                "DELETE FROM context_entries "
+                "WHERE session_id=? AND computed_at < ?",
+                (session_id, cutoff),
+            )
         return cur.rowcount
 
     def cleanup_global_lru(self) -> int:
@@ -309,17 +348,17 @@ class ContextCache:
         target = int(MAX_BYTES * 0.9)
         while total > target:
             rows = self._write_conn.execute(
-                "SELECT session_id, topic_sig, byte_size "
+                "SELECT profile_id, session_id, topic_sig, byte_size "
                 "FROM context_entries "
                 "ORDER BY computed_at ASC LIMIT 100",
             ).fetchall()
             if not rows:  # pragma: no cover — reached only if table empties mid-sweep
                 break
-            for sess, sig, size in rows:
+            for pid, sess, sig, size in rows:
                 self._write_conn.execute(
                     "DELETE FROM context_entries "
-                    "WHERE session_id=? AND topic_sig=?",
-                    (sess, sig),
+                    "WHERE profile_id=? AND session_id=? AND topic_sig=?",
+                    (pid, sess, sig),
                 )
                 deleted += 1
                 total -= size
@@ -345,6 +384,7 @@ def read_entry_fast(
     *,
     db_path: Path | None = None,
     home_dir: Path | None = None,
+    profile_id: str | None = None,
 ) -> CacheEntry | None:
     """Hot-path reader used by the UserPromptSubmit hook.
 
@@ -397,14 +437,17 @@ def read_entry_fast(
                 return None
 
             now = int(time.time())
+            # Scope to the active profile so a shared session_id cannot read
+            # another tenant's cached context.
+            pid = profile_id or _active_profile_fallback(home)
             row = conn.execute(
                 """
                 SELECT content, fact_ids, provenance, computed_at, byte_size
                 FROM context_entries
-                WHERE session_id=? AND topic_sig=?
+                WHERE profile_id=? AND session_id=? AND topic_sig=?
                   AND computed_at > ?
                 """,
-                (session_id, topic_sig, now - TTL_SECONDS),
+                (pid, session_id, topic_sig, now - TTL_SECONDS),
             ).fetchone()
         finally:
             try:

package/src/superlocalmemory/core/embedding_worker.py

@@ -65,6 +65,21 @@ def _embedding_backend_order() -> tuple[str, str]:
     return ("onnx", "pytorch")
 
 
+# H-02 (3.7.9): trust_remote_code=_trusts_remote_code(name) runs arbitrary Python from the model
+# repository at load time. Restrict it to the pinned models SLM ships that
+# genuinely need custom modeling code (nomic-embed). Any other model — including
+# one swapped into config by a write-path attacker — loads with
+# trust_remote_code=False and therefore cannot execute repo code.
+_TRUSTED_REMOTE_CODE_MODELS = frozenset({
+    "nomic-ai/nomic-embed-text-v1.5",
+    "nomic-ai/nomic-embed-text-v1",
+})
+
+
+def _trusts_remote_code(model_name: str) -> bool:
+    return model_name in _TRUSTED_REMOTE_CODE_MODELS
+
+
 def _load_embedding_model(name: str) -> tuple:
     """Load embedding model. ONNX CPU-only first, PyTorch fallback.
 
@@ -84,14 +99,14 @@ def _load_embedding_model(name: str) -> tuple:
                 m = SentenceTransformer(
                     name,
                     backend="onnx",
-                    trust_remote_code=True,
+                    trust_remote_code=_trusts_remote_code(name),
                     model_kwargs={"provider": "CPUExecutionProvider"},
                 )
             else:
                 import torch
                 with torch.inference_mode():
                     m = SentenceTransformer(
-                        name, trust_remote_code=True, device="cpu",
+                        name, trust_remote_code=_trusts_remote_code(name), device="cpu",
                     )
             return m, backend
         except Exception:

package/src/superlocalmemory/core/embeddings.py

@@ -295,7 +295,13 @@ class EmbeddingService:
         never hangs indefinitely on cold model loads or network issues.
         """
         with self._lock:
-            if not self._available:
+            # Only an explicit terminal disable (``False``) short-circuits. A
+            # ``None`` availability is the recall-health self-heal's "re-probe"
+            # signal (recall_health._heal_embedder) — it must fall through and
+            # respawn the worker, matching OllamaEmbedder's tri-state
+            # convention. Using ``not self._available`` here bricked the local
+            # worker on the first heal tick, because ``None`` is falsy.
+            if self._available is False:
                 return None
             # Worker recycling: restart after N requests to prevent
             # C++ allocator fragmentation over long-running sessions.
@@ -348,6 +354,11 @@ class EmbeddingService:
                     self._available = False
                     self._kill_worker()
                     return None
+                # A successful embed proves the worker is healthy, so clear any
+                # transient/``None`` availability left by a self-heal re-probe
+                # back to a definite ``True``. Without this the flag lingers at
+                # ``None`` and the next ``not``-style check elsewhere re-blocks.
+                self._available = True
                 self._reset_idle_timer()
                 self._request_count += 1
                 return resp["vectors"]