superlocalmemory 3.8.3 → 3.8.5

package/src/superlocalmemory/cli/main.py

@@ -252,6 +252,36 @@ def main() -> None:
         "--dry-run", action="store_true", dest="dry_run", default=False,
         help="Show what would be written without making changes",
     )
+    # Workstream C — transport flexibility (3.8.4)
+    connect_p.add_argument(
+        "--transport",
+        choices=["stdio", "http", "http-mcp-remote"],
+        default="stdio",
+        dest="transport",
+        help=(
+            "MCP transport to write into the IDE config. "
+            "stdio (default, zero regression) | "
+            "http (native Streamable-HTTP, requires SLM daemon) | "
+            "http-mcp-remote (stdio bridge via mcp-remote for stdio-only clients)"
+        ),
+    )
+    connect_p.add_argument(
+        "--port",
+        type=int,
+        default=8765,
+        dest="daemon_port",
+        help="SLM daemon port for http/http-mcp-remote transport (default: 8765)",
+    )
+    connect_p.add_argument(
+        "--verify",
+        action="store_true",
+        default=False,
+        dest="verify",
+        help=(
+            "After writing the config, probe the daemon health endpoint to confirm "
+            "the transport is reachable (only meaningful for --transport http)"
+        ),
+    )
 
     migrate_p = sub.add_parser("migrate", help="Migrate data from V2 to V3 schema")
     migrate_p.add_argument(

package/src/superlocalmemory/cli/pending_store.py

@@ -40,6 +40,13 @@ _MAX_RETRIES = 3
 _STUCK_DAYS = 7
 _MAX_RETRY_DELAY_SECONDS = 3600
 
+# Fix F: hard cap on pending.db retries. After this many failed attempts the
+# item transitions to status='dead_letter' (next_retry_at=NULL) so it is
+# permanently excluded from the work queue.  Value chosen to survive transient
+# engine unavailability (12h at 30-min drain intervals) while still providing
+# a definitive signal for genuinely poisoned content.
+_MAX_RETRY_COUNT: int = 20
+
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS pending_memories (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -180,9 +187,17 @@ def mark_done(row_id: int, base_dir: Path | None = None) -> None:
 def mark_failed(row_id: int, error: str, base_dir: Path | None = None) -> None:
     """Mark a pending memory as failed with error message.
 
-    Unprocessed evidence is never deleted or terminally hidden. Failures stay
-    pending with bounded exponential backoff; M018 idempotency makes repeated
-    replay safe once the canonical operation has been created.
+    Fix F: when the retry counter reaches _MAX_RETRY_COUNT the item transitions
+    to ``status='dead_letter'`` with ``next_retry_at=NULL``.  Dead-lettered
+    items are excluded from the work queue (``get_pending`` filters
+    ``status='pending'``) and are not resurrected by the startup
+    ``UPDATE…WHERE status='failed'`` sweep (which targets only 'failed', not
+    'dead_letter').  This gives operators a stable, inspectable record of
+    genuinely poisoned content instead of an infinite retry loop.
+
+    Below the cap, failures stay pending with bounded exponential backoff;
+    M018 idempotency makes repeated replay safe once the canonical operation
+    has been created.
     """
     conn = _get_db(base_dir)
     try:
@@ -193,17 +208,27 @@ def mark_failed(row_id: int, error: str, base_dir: Path | None = None) -> None:
         if row is None:
             return
         next_count = int(row[0] or 0) + 1
-        delay = 0 if next_count == 1 else min(
-            2 ** min(next_count - 1, 12),
-            _MAX_RETRY_DELAY_SECONDS,
-        )
-        conn.execute(
-            "UPDATE pending_memories SET error = ?, "
-            "retry_count = retry_count + 1, "
-            "status = 'pending', next_retry_at = ? "
-            "WHERE id = ?",
-            (error, time.time() + delay, row_id),
-        )
+        if next_count >= _MAX_RETRY_COUNT:
+            # Fix F: permanently exclude from work queue — dead-letter.
+            conn.execute(
+                "UPDATE pending_memories SET error = ?, "
+                "retry_count = retry_count + 1, "
+                "status = 'dead_letter', next_retry_at = NULL "
+                "WHERE id = ?",
+                (error, row_id),
+            )
+        else:
+            delay = 0 if next_count == 1 else min(
+                2 ** min(next_count - 1, 12),
+                _MAX_RETRY_DELAY_SECONDS,
+            )
+            conn.execute(
+                "UPDATE pending_memories SET error = ?, "
+                "retry_count = retry_count + 1, "
+                "status = 'pending', next_retry_at = ? "
+                "WHERE id = ?",
+                (error, time.time() + delay, row_id),
+            )
         conn.commit()
     finally:
         conn.close()

package/src/superlocalmemory/core/backend_orchestrator.py

@@ -100,6 +100,11 @@ class BackendOrchestrator:
                 "Scale Engine remains on Local Core (state=%s)",
                 getattr(self._config, "scale_engine_state", "local_core"),
             )
+            # v3.8.5: schedule a background check that auto-promotes to
+            # Cozo+LanceDB only once the DB is large enough that they beat the
+            # SQLite graph.  A no-op (and never even starts the build) for the
+            # vast majority of installs, which sit far below the threshold.
+            self._maybe_schedule_auto_promote()
             return
 
         # 3. Initialize CozoDB if available
@@ -129,6 +134,94 @@ class BackendOrchestrator:
                      "active" if self._cozo and self._cozo_status() == "active" else "off",
                      "active" if self._lancedb and self._lancedb_status() == "active" else "off")
 
+    def _maybe_schedule_auto_promote(self) -> None:
+        """Schedule a delayed, one-shot scale auto-promote check (v3.8.5).
+
+        Fires well after boot warmup so it never competes for CPU / the write
+        lock during the startup window — the daemon keeps serving canonical
+        SQLite throughout.  A no-op (never even starts the build) unless
+        auto-promotion is enabled AND the DB has grown past the threshold where
+        a graph DB actually beats the well-indexed SQLite graph.
+        """
+        import os
+        import threading
+
+        cfg = self._config
+        if not getattr(cfg, "scale_auto_promote_enabled", True):
+            return
+        if getattr(cfg, "scale_engine_state", "local_core") != "local_core":
+            return
+        try:
+            delay = float(os.environ.get("SLM_AUTO_PROMOTE_DELAY_S", "300"))
+        except (TypeError, ValueError):
+            delay = 300.0
+        timer = threading.Timer(delay, self._auto_promote_if_at_scale)
+        timer.daemon = True
+        timer.start()
+
+    def _count_default_edges(self) -> int:
+        """graph_edges count for the default profile (fail-soft → 0)."""
+        try:
+            rows = self._db.execute(
+                "SELECT COUNT(*) AS c FROM graph_edges WHERE profile_id = 'default'"
+            )
+            return int(rows[0]["c"]) if rows else 0
+        except Exception:
+            return 0
+
+    def _auto_promote_if_at_scale(self) -> None:
+        """Build + promote the Cozo/Lance projection iff the DB is at scale.
+
+        Uses the SAME staged parity gate as the manual CLI path
+        (prepare → verify → promote).  Any failure leaves canonical SQLite
+        selected — the projection is derived data, never the source of truth.
+        The promoted backends only serve after the next daemon restart, so this
+        logs a clear, actionable message rather than swapping under a live
+        process.
+        """
+        try:
+            import os
+
+            cfg = self._config
+            if getattr(cfg, "scale_engine_state", "local_core") != "local_core":
+                return
+            threshold = int(
+                os.environ.get("SLM_AUTO_PROMOTE_MIN_EDGES", "")
+                or getattr(cfg, "scale_auto_promote_min_edges", 1_000_000)
+            )
+            edges = self._count_default_edges()
+            if edges < threshold:
+                logger.info(
+                    "Scale auto-promote: %d edges < threshold %d — Local Core "
+                    "(SQLite) stays optimal; no projection built.",
+                    edges, threshold,
+                )
+                return
+            logger.info(
+                "Scale auto-promote: %d edges >= threshold %d — building "
+                "Cozo+LanceDB projection in the background (SQLite keeps serving).",
+                edges, threshold,
+            )
+            from superlocalmemory.core.scale_engine import ScaleEngineManager
+
+            mgr = ScaleEngineManager(cfg, profile_id="default")
+            prepared = mgr.prepare()
+            stage_id = prepared.get("stage_id")
+            mgr.verify(stage_id)
+            mgr.promote(stage_id)
+            logger.warning(
+                "Scale Engine AUTO-PROMOTED to Cozo+LanceDB at %d edges. RESTART "
+                "the daemon (`slm restart`) to activate the backends; until then "
+                "it keeps serving canonical SQLite.",
+                edges,
+            )
+        except Exception as exc:
+            # Derived-data failure must never take down Local Core.
+            logger.warning(
+                "Scale auto-promote skipped — staying on Local Core / SQLite: %s",
+                exc,
+            )
+
     def _recover_interrupted_scale_promotion(self) -> None:
         """Repair an interrupted promotion; never auto-mutate a legacy root."""
         try:

package/src/superlocalmemory/core/config.py

@@ -960,6 +960,29 @@ class HealthConfig:
     enable_structured_logging: bool = True
 
 
+# ---------------------------------------------------------------------------
+# Graph Pruning Config (Workstream G — #84)
+# ---------------------------------------------------------------------------
+
+@dataclass
+class GraphPruningConfig:
+    """Graph thinning parameters.  Exposed via dashboard + CLI.
+
+    Defaults reproduce the previous hard-coded behaviour so existing
+    deployments see zero behavioural change after upgrade.
+    """
+
+    #: Maximum in- or out-degree per node.  Maps to the legacy module-level
+    #: ``_MAX_DEGREE_PER_NODE = 100`` in graph_pruner.py.
+    max_degree_per_node: int = 100
+    #: Discard edges with weight strictly below this floor.
+    #: 0.0 = no floor (current behaviour, always-safe default).
+    min_edge_weight: float = 0.0
+    #: Master kill-switch for all graph pruning.  ``False`` skips the entire
+    #: prune step (useful for debugging graph bloat).
+    enabled: bool = True
+
+
 # ---------------------------------------------------------------------------
 # Master Config
 # ---------------------------------------------------------------------------
@@ -1008,8 +1031,19 @@ class SLMConfig:
     # Scale Engine is installed separately from activation.  Existing roots
     # stay on SQLite until a staged parity check promotes these projections.
     scale_engine_state: str = "local_core"  # local_core | prepared | verified | promoted
+    # v3.8.5: auto-promote Cozo+LanceDB when a DB grows past the scale at which
+    # they actually help.  Below the threshold the well-indexed SQLite graph is
+    # faster (measured ~1.7ms/traversal at 208K edges), so normal installs stay
+    # on Local Core and never pay the projection/migration cost.  The threshold
+    # is deliberately high: the graph DB win appears at millions of edges, not
+    # hundreds of thousands.  Auto-promotion is background, uses the same staged
+    # parity gate as the manual path, and falls back to SQLite on any failure.
+    scale_auto_promote_enabled: bool = True
+    scale_auto_promote_min_edges: int = 1_000_000
     evolution: EvolutionConfig = field(default_factory=EvolutionConfig)
     health: HealthConfig = field(default_factory=HealthConfig)
+    # v3.8.4-G: Graph thinning parameters (#84)
+    graph_pruning: GraphPruningConfig = field(default_factory=GraphPruningConfig)
 
     # v3.4.3: Daemon configuration
     daemon_idle_timeout: int = 0       # 0 = 24/7 (no auto-kill). >0 = seconds before auto-kill.
@@ -1122,6 +1156,15 @@ class SLMConfig:
             state if state in {"local_core", "prepared", "verified", "promoted"}
             else "local_core"
         )
+        config.scale_auto_promote_enabled = bool(
+            data.get("scale_auto_promote_enabled", True)
+        )
+        try:
+            config.scale_auto_promote_min_edges = int(
+                data.get("scale_auto_promote_min_edges", 1_000_000)
+            )
+        except (TypeError, ValueError):
+            config.scale_auto_promote_min_edges = 1_000_000
 
         # V3.3 config fields (additive — defaults work if missing from JSON)
         fg = data.get("forgetting", {})
@@ -1174,6 +1217,31 @@ class SLMConfig:
                 if k in HealthConfig.__dataclass_fields__
             })
 
+        # v3.8.4-G: Graph pruning config (#84) — additive, no migration needed.
+        # Old configs without this section silently fall back to GraphPruningConfig()
+        # defaults, which reproduce the existing _MAX_DEGREE_PER_NODE=100 behaviour.
+        gp_raw = data.get("graph_pruning", {})
+        if gp_raw:
+            try:
+                gp_kwargs = {
+                    k: v for k, v in gp_raw.items()
+                    if k in GraphPruningConfig.__dataclass_fields__
+                }
+                gp = GraphPruningConfig(**gp_kwargs)
+                # Validate and clamp out-of-range values
+                max_deg = gp.max_degree_per_node if gp.max_degree_per_node >= 1 else 100
+                min_w = max(0.0, min(1.0, gp.min_edge_weight))
+                config.graph_pruning = GraphPruningConfig(
+                    max_degree_per_node=max_deg,
+                    min_edge_weight=min_w,
+                    enabled=gp.enabled,
+                )
+            except (ValueError, TypeError) as exc:
+                logger.warning(
+                    "graph_pruning config invalid (%s) — using defaults", exc
+                )
+                config.graph_pruning = GraphPruningConfig()
+
         # V3.4.65: Injection config (additive — defaults if missing from JSON)
         inj = data.get("injection", {}) or {}
         config.injection = InjectionConfig(
@@ -1271,6 +1339,8 @@ class SLMConfig:
             "graph_backend": self.graph_backend,
             "vector_backend": self.vector_backend,
             "scale_engine_state": self.scale_engine_state,
+            "scale_auto_promote_enabled": self.scale_auto_promote_enabled,
+            "scale_auto_promote_min_edges": self.scale_auto_promote_min_edges,
             "base_dir": str(self.base_dir),  # V3.5.9: persist so load() can restore custom paths
             "llm": {
                 "provider": self.llm.provider,
@@ -1329,6 +1399,14 @@ class SLMConfig:
         # Multi-scope memory: behaviour defaults
         data["scope"] = self.scope.as_dict()
 
+        # v3.8.4-G: Persist graph pruning config (#84).
+        # Always written — additive key, never overwrites unrelated sections.
+        data["graph_pruning"] = {
+            "max_degree_per_node": self.graph_pruning.max_degree_per_node,
+            "min_edge_weight": self.graph_pruning.min_edge_weight,
+            "enabled": self.graph_pruning.enabled,
+        }
+
         # Preserve existing V3.3 config sections that aren't in for_mode()
         for key in ("forgetting", "quantization", "sagq", "embedding_signature", "auto_invoke"):
             if key in existing:

package/src/superlocalmemory/core/consolidation_engine.py

@@ -708,93 +708,99 @@ class ConsolidationEngine:
         Uses 'custom' category because the soft_prompt_templates CHECK
         constraint does not include 'skill_evolution'. The content is
         prefixed with [SKILL_EVOLUTION] for easy filtering.
-        """
-        import sqlite3 as _sqlite3
 
-        db_path = str(self._db.db_path)
+        Concurrency fix (v3.8.4): all writes routed through memory_write()
+        so the process write lock (get_write_lock) serialises in-process
+        writers and proper busy_timeout handles cross-process races.
+        No slow ops are held inside the write lock — this method has none.
+        """
+        from superlocalmemory.storage.memory_write import memory_read, memory_write
 
-        conn = _sqlite3.connect(db_path, timeout=10)
-        conn.row_factory = _sqlite3.Row
+        db_path = self._db.db_path
 
-        # Fetch promoted evolutions
+        # Phase 1: read-only fetch — does NOT hold the write lock.
         try:
-            promoted_rows = conn.execute(
-                "SELECT id, skill_name, parent_skill_id, evolution_type, "
-                "mutation_summary, created_at "
-                "FROM skill_evolution_log "
-                "WHERE status = 'promoted' "
-                "ORDER BY created_at DESC LIMIT 20",
-            ).fetchall()
-        except _sqlite3.OperationalError:
+            with memory_read(db_path) as rconn:
+                promoted_rows = [
+                    dict(r)
+                    for r in rconn.execute(
+                        "SELECT id, skill_name, parent_skill_id, evolution_type, "
+                        "mutation_summary, created_at "
+                        "FROM skill_evolution_log "
+                        "WHERE status = 'promoted' "
+                        "ORDER BY created_at DESC LIMIT 20",
+                    ).fetchall()
+                ]
+        except Exception:
             # Table may not exist yet
-            conn.close()
             return {"created": 0, "message": "skill_evolution_log table not found"}
 
-        created_count = 0
+        if not promoted_rows:
+            return {"promoted_skills_found": 0, "soft_prompts_created": 0}
+
         now = datetime.now(timezone.utc).isoformat()
+        created_count = 0
 
-        for row in promoted_rows:
-            r = dict(row)
-            skill_name = r["skill_name"]
-            parent = r.get("parent_skill_id") or skill_name
-            evo_type = r["evolution_type"]
-            summary = r.get("mutation_summary", "")
-            evo_id = r["id"]
-
-            # Build prompt content
-            content = (
-                f"[SKILL_EVOLUTION] Evolved skill: '{skill_name}' "
-                f"({'replaces' if evo_type == 'fix' else 'extends'} '{parent}' "
-                f"via {evo_type}). {summary}. "
-                f"Use the evolved version for better results."
-            )
+        # Phase 2: short write transaction — hold the write lock for the
+        # INSERT/UPDATE loop only (pure SQL, no network / embed calls).
+        with memory_write(db_path) as conn:
+            for r in promoted_rows:
+                skill_name = r["skill_name"]
+                parent = r.get("parent_skill_id") or skill_name
+                evo_type = r["evolution_type"]
+                summary_txt = r.get("mutation_summary", "")
+                evo_id = r["id"]
+
+                content = (
+                    f"[SKILL_EVOLUTION] Evolved skill: '{skill_name}' "
+                    f"({'replaces' if evo_type == 'fix' else 'extends'} '{parent}' "
+                    f"via {evo_type}). {summary_txt}. "
+                    f"Use the evolved version for better results."
+                )
+                prompt_id = f"evo-{evo_id}"
 
-            # Use a deterministic prompt_id based on the evolution record
-            prompt_id = f"evo-{evo_id}"
+                existing = conn.execute(
+                    "SELECT prompt_id FROM soft_prompt_templates WHERE prompt_id = ?",
+                    (prompt_id,),
+                ).fetchone()
 
-            # Check if prompt already exists
-            existing = conn.execute(
-                "SELECT prompt_id FROM soft_prompt_templates WHERE prompt_id = ?",
-                (prompt_id,),
-            ).fetchone()
+                if existing:
+                    # M-REPLACE: Update existing record instead of INSERT OR REPLACE
+                    # to avoid silently dropping columns with defaults.
+                    try:
+                        conn.execute(
+                            "UPDATE soft_prompt_templates "
+                            "SET content = ?, updated_at = ? "
+                            "WHERE prompt_id = ?",
+                            (content, now, prompt_id),
+                        )
+                    except Exception as upd_exc:
+                        logger.debug(
+                            "Failed to update soft prompt %s: %s", prompt_id, upd_exc
+                        )
+                    continue
 
-            if existing:
-                # M-REPLACE: Update existing record instead of INSERT OR REPLACE
-                # to avoid silently dropping columns with defaults
                 try:
-                    conn.execute(
-                        "UPDATE soft_prompt_templates "
-                        "SET content = ?, updated_at = ? "
-                        "WHERE prompt_id = ?",
-                        (content, now, prompt_id),
+                    cur = conn.execute(
+                        "INSERT OR IGNORE INTO soft_prompt_templates "
+                        "(prompt_id, profile_id, category, content, source_pattern_ids, "
+                        " confidence, effectiveness, token_count, retention_score, "
+                        " active, version, created_at, updated_at) "
+                        "VALUES (?, ?, 'custom', ?, ?, 0.8, 0.5, ?, 1.0, 1, 1, ?, ?)",
+                        (
+                            prompt_id, profile_id, content,
+                            json.dumps([evo_id]),
+                            len(content.split()),
+                            now, now,
+                        ),
+                    )
+                    if cur.rowcount > 0:
+                        created_count += 1
+                except Exception as ins_exc:
+                    # Unique constraint on (profile_id, category) WHERE active=1
+                    logger.debug(
+                        "Skipping soft prompt for %s: %s", skill_name, ins_exc
                     )
-                except _sqlite3.OperationalError as upd_exc:
-                    logger.debug("Failed to update soft prompt %s: %s", prompt_id, upd_exc)
-                continue
-
-            try:
-                conn.execute(
-                    "INSERT OR IGNORE INTO soft_prompt_templates "
-                    "(prompt_id, profile_id, category, content, source_pattern_ids, "
-                    " confidence, effectiveness, token_count, retention_score, "
-                    " active, version, created_at, updated_at) "
-                    "VALUES (?, ?, 'custom', ?, ?, 0.8, 0.5, ?, 1.0, 1, 1, ?, ?)",
-                    (prompt_id, profile_id, content,
-                     json.dumps([evo_id]),
-                     len(content.split()),  # Rough token estimate
-                     now, now),
-                )
-                if conn.total_changes:
-                    created_count += 1
-            except _sqlite3.IntegrityError:
-                # Unique constraint on (profile_id, category) WHERE active=1
-                logger.debug(
-                    "Skipping soft prompt for %s: unique constraint on active custom",
-                    skill_name,
-                )
-
-        conn.commit()
-        conn.close()
 
         return {
             "promoted_skills_found": len(promoted_rows),

package/src/superlocalmemory/core/engine.py

@@ -18,6 +18,8 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 from __future__ import annotations
 
 import logging
+import os
+import threading
 from pathlib import Path
 from typing import Any
 
@@ -26,7 +28,7 @@ from superlocalmemory.core.engine_capabilities import Capabilities, CapabilityEr
 from superlocalmemory.core.modes import get_capabilities
 from superlocalmemory.learning.outcome_queue import RecallEvent, enqueue_recall
 from superlocalmemory.storage.models import (
-    AtomicFact, MemoryRecord, Mode, RecallResponse,
+    AtomicFact, FactType, MemoryRecord, Mode, RecallResponse,
 )
 
 logger = logging.getLogger(__name__)
@@ -47,6 +49,34 @@ def _verify_ingestion_schema(memory_db: Path) -> bool:
         connection.close()
 
 
+# ---------------------------------------------------------------------------
+# Workstream D (3.8.4) — warm-guard sync embed helpers
+# ---------------------------------------------------------------------------
+
+def _is_remote_embedder(embedder: object) -> bool:
+    """Return True if *embedder* makes remote HTTP calls (cloud / OpenAI-compatible).
+
+    Remote embedders (100–400ms round-trip) must never block the store_fast()
+    write path synchronously — they stay on the async materializer path.
+
+    Local embedders:
+      - EmbeddingService (subprocess, local ONNX/sentence-transformers): has
+        ``_config`` with ``is_cloud=False`` and ``is_openai_compatible=False``.
+      - OllamaEmbedder (localhost HTTP, ~73ms): has NO ``_config`` attribute.
+
+    Remote embedders:
+      - EmbeddingService with ``_config.is_cloud=True`` (Azure, etc.)
+      - EmbeddingService with ``_config.is_openai_compatible=True``
+    """
+    cfg = getattr(embedder, "_config", None)
+    if cfg is None:
+        return False  # OllamaEmbedder — local
+    return bool(
+        getattr(cfg, "is_cloud", False)
+        or getattr(cfg, "is_openai_compatible", False)
+    )
+
+
 class MemoryEngine:
     """Main orchestrator for the SuperLocalMemory V3 memory system.
 
@@ -103,6 +133,11 @@ class MemoryEngine:
         self._consolidation_engine = None
         self._maintenance_scheduler = None
         self._hooks = HookRegistry()
+        # Workstream D (3.8.4): single-worker pool reused across store_fast() calls.
+        # Lazy-created on first warm-guard attempt; avoids per-call thread churn.
+        self._store_fast_embed_pool: object | None = None
+        # Lock guards the lazy-init to prevent TOCTOU race on concurrent first calls.
+        self._store_fast_embed_pool_lock = threading.Lock()
 
     # -- Public properties (Phase 2+ access) --------------------------------
 
@@ -525,9 +560,6 @@ class MemoryEngine:
         import re as _re
         import uuid as _uuid
         from datetime import datetime, timezone
-        from superlocalmemory.storage.models import (
-            AtomicFact, FactType, MemoryRecord,
-        )
         from superlocalmemory.core.engine_ingestion import content_passes_admission
         if not content_passes_admission(content):
             return []
@@ -568,15 +600,64 @@ class MemoryEngine:
                 r"\b([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})\b", fact_text)}
             | {m.group(1) for m in _re.finditer(r"\b([A-Z]{2,})\b", fact_text)}
         )
-        # Queryable admission must never acquire the embedding worker lock.
-        # On a warm daemon that looked cheap, but on a clean Mode A install the
-        # background model load owns that lock for up to 180s and turned the
-        # receipt-first path into a hidden synchronous wait.  The canonical
-        # materializer below runs the complete pipeline and promotes this same
-        # fact with its embedding, Fisher parameters, entities and graph edges.
-        # Until then it is deliberately BM25/entity/date recallable.
+        # Workstream D (3.8.4) — warm-guard synchronous embed.
+        #
+        # Original contract (3.8.2): queryable admission NEVER acquires the
+        # embedding worker lock. On a clean Mode-A install the background model
+        # load owns that lock for up to 180s, turning the receipt-first path into
+        # a hidden synchronous wait. The canonical materializer promotes this
+        # fact with its full pipeline (embedding, Fisher, entities, graph edges).
+        #
+        # 3.8.4 extension: when the embedder is PROVABLY warm (_available is True)
+        # AND is a local embedder (not a remote cloud/OpenAI endpoint), compute the
+        # embedding synchronously with a hard 500ms cap. On timeout or any
+        # exception, fall through to emb=None — the materializer fills it async.
+        # This preserves the 3.8.2 invariant for cold start while eliminating the
+        # semantic-channel blind spot on warm daemons (the top UX complaint).
         emb = None
         fmean = fvar = None
+        _embedder_ref = self._embedder
+        if (
+            _embedder_ref is not None
+            and getattr(_embedder_ref, "_available", None) is True
+            and not _is_remote_embedder(_embedder_ref)
+        ):
+            import concurrent.futures as _cf
+            # Lazy-init the pool once per engine instance — avoids per-call
+            # thread churn and the associated resource leak from discard-on-exit.
+            # Double-checked locking guards against TOCTOU on concurrent first calls.
+            if self._store_fast_embed_pool is None:
+                with self._store_fast_embed_pool_lock:
+                    if self._store_fast_embed_pool is None:
+                        self._store_fast_embed_pool = _cf.ThreadPoolExecutor(
+                            max_workers=1,
+                            thread_name_prefix="slm-sg-embed",
+                        )
+            try:
+                _timeout_s = int(os.environ.get("SLM_STORE_FAST_EMBED_TIMEOUT_MS", 500)) / 1000.0
+            except (ValueError, TypeError):
+                _timeout_s = 0.5  # default 500 ms
+            try:
+                _future = self._store_fast_embed_pool.submit(_embedder_ref.embed, fact_text)
+                try:
+                    emb = _future.result(timeout=_timeout_s)
+                    if emb:
+                        fmean, fvar = _embedder_ref.compute_fisher_params(emb)
+                except _cf.TimeoutError:
+                    logger.debug(
+                        "store_fast: warm-guard embed timed out (>%.0fms) — deferring to materializer",
+                        _timeout_s * 1000,
+                    )
+                    emb = None
+                except Exception as _exc:
+                    logger.debug(
+                        "store_fast: warm-guard embed failed (%s) — deferring to materializer",
+                        _exc,
+                    )
+                    emb = None
+            except Exception as _exc:
+                logger.debug("store_fast: warm-guard pool submit failed (%s)", _exc)
+                emb = None
         fact = AtomicFact(
             fact_id=_uuid.uuid4().hex[:16], memory_id=record.memory_id,
             profile_id=self._profile_id, content=fact_text,