superlocalmemory 3.6.3__tar.gz → 3.6.4__tar.gz

{superlocalmemory-3.6.3/src/superlocalmemory.egg-info → superlocalmemory-3.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.6.3
+Version: 3.6.4
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/pyproject.toml

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

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/consolidation_engine.py

@@ -745,6 +745,14 @@ class ConsolidationEngine:
         """
         from superlocalmemory.storage.models import _new_id
 
+        # NOTE (core-promotion-02, intentionally NOT changed): the audit
+        # flagged placeholder core blocks ("No data available.") + version
+        # churn. Investigation showed BOTH the "always 5 blocks" layout and the
+        # monotonic version-on-recompile counter are intentional, tested design
+        # (see test_consolidation_engine), and the read-side injection filter
+        # already hides placeholders from agents. Suppressing or de-churning
+        # here breaks that design for a cosmetic gain — so it is left as-is.
+
         # Get existing version for increment
         existing = self._db.get_core_block(profile_id, block_type)
         version = (existing["version"] + 1) if existing else 1

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/engine.py

@@ -281,13 +281,18 @@ class MemoryEngine:
         # V3.2: ConsolidationEngine (Phase 5) -- sleep-time consolidation
         from superlocalmemory.core.summarizer import Summarizer
         summarizer = Summarizer(self._config)
+        # P1-5 (core-promotion-01): wire a real behavioral store. Previously
+        # hardcoded None → _compile_behavioral_block always returned the
+        # "No behavioral patterns detected yet." placeholder, so behavioral
+        # patterns never reached the always-injected core block (dead feature).
+        from superlocalmemory.core.recall_pipeline import _get_behavioral_tracker
         self._consolidation_engine = _init_consolidation(
             self._config, self._db,
             auto_linker=self._auto_linker,
             graph_analyzer=self._graph_analyzer,
             temporal_validator=self._temporal_validator,
             summarizer=summarizer,
-            behavioral_store=None,
+            behavioral_store=_get_behavioral_tracker(self._db),
             embedder=self._embedder,  # v3.4.7: for CCQ worker
             llm=getattr(self, "_llm", None),  # v3.4.7: for CCQ worker
         )

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/fact_consolidator.py

@@ -226,19 +226,41 @@ def _consolidate_cluster(
                 except (json.JSONDecodeError, TypeError):
                     pass
 
-        c.execute("""
-            INSERT INTO atomic_facts
-            (fact_id, memory_id, profile_id, content, fact_type,
-             entities_json, canonical_entities_json,
-             confidence, importance, evidence_count, access_count,
-             created_at, lifecycle)
-            VALUES (?, '', ?, ?, 'semantic', ?, ?, ?, 0.8, ?, 0, ?, 'active')
-        """, (
-            new_fact_id, profile_id, summary,
-            json.dumps(list(all_entities)),
-            json.dumps(list(all_entities)),
-            round(avg_confidence, 3), len(facts), now,
-        ))
+        # P0-3 (dedup-complete-01): apply the SAME content-idempotency invariant
+        # as storage.database.store_fact — but on THIS cursor so it stays inside
+        # the cluster SAVEPOINT. Previously this raw INSERT bypassed dedup, so a
+        # consolidated summary identical to an existing live fact created a
+        # duplicate row and never reinforced evidence. Now: reinforce-or-insert.
+        # (Excludes 'archived' = soft-deleted, mirroring store_fact.)
+        _existing = c.execute(
+            "SELECT fact_id FROM atomic_facts "
+            "WHERE profile_id = ? AND content = ? "
+            "AND lifecycle IN ('active', 'warm', 'cold') "
+            "ORDER BY created_at LIMIT 1",
+            (profile_id, summary),
+        ).fetchone()
+        if _existing:
+            new_fact_id = _existing["fact_id"]
+            c.execute(
+                "UPDATE atomic_facts "
+                "SET evidence_count = evidence_count + ?, access_count = access_count + 1 "
+                "WHERE fact_id = ?",
+                (len(facts), new_fact_id),
+            )
+        else:
+            c.execute("""
+                INSERT INTO atomic_facts
+                (fact_id, memory_id, profile_id, content, fact_type,
+                 entities_json, canonical_entities_json,
+                 confidence, importance, evidence_count, access_count,
+                 created_at, lifecycle)
+                VALUES (?, '', ?, ?, 'semantic', ?, ?, ?, 0.8, ?, 0, ?, 'active')
+            """, (
+                new_fact_id, profile_id, summary,
+                json.dumps(list(all_entities)),
+                json.dumps(list(all_entities)),
+                round(avg_confidence, 3), len(facts), now,
+            ))
 
         # Record the consolidation
         consolidation_id = uuid.uuid4().hex[:16]
@@ -257,6 +279,25 @@ def _consolidate_cluster(
             (*fact_ids, profile_id),
         )
 
+        # P1-4 (graph-integrity-01): archived facts must stop influencing
+        # graph-based ranking. The association_edges FK is ON DELETE CASCADE
+        # only (no ON UPDATE), so archiving via UPDATE leaves orphaned edges
+        # that spreading_activation still reads. Remove edges touching the
+        # archived facts, and set their retention zone so ForgettingFilter
+        # excludes them. Inside the SAVEPOINT for atomicity.
+        c.execute(
+            f"DELETE FROM association_edges "
+            f"WHERE profile_id = ? "
+            f"AND (source_fact_id IN ({placeholders}) "
+            f"     OR target_fact_id IN ({placeholders}))",
+            (profile_id, *fact_ids, *fact_ids),
+        )
+        c.execute(
+            f"UPDATE fact_retention SET lifecycle_zone = 'archive' "
+            f"WHERE profile_id = ? AND fact_id IN ({placeholders})",
+            (profile_id, *fact_ids),
+        )
+
         c.execute(f"RELEASE SAVEPOINT {savepoint_name}")
 
     except Exception:

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/graph_pruner.py

@@ -56,6 +56,7 @@ def prune_graph(
         "self_loops_removed": 0,
         "duplicates_removed": 0,
         "hub_edges_removed": 0,
+        "association_orphans_removed": 0,  # gi-04
         "total_before": 0,
         "total_after": 0,
     }
@@ -83,6 +84,9 @@ def prune_graph(
             stats["hub_edges_removed"] = _cap_node_degree(
                 c, profile_id, _MAX_DEGREE_PER_NODE, dry_run,
             )
+        stats["association_orphans_removed"] = _remove_orphan_association_edges(
+            c, profile_id, dry_run,
+        )
 
         if dry_run:
             c.execute("ROLLBACK")
@@ -122,6 +126,34 @@ def prune_graph(
     return stats
 
 
+def _remove_orphan_association_edges(
+    c: sqlite3.Cursor,
+    profile_id: str,
+    dry_run: bool,
+) -> int:
+    """gi-04: remove association_edges whose source/target fact no longer
+    exists in atomic_facts.
+
+    prune_graph historically only touched graph_edges despite its docstring
+    claiming "all graph pruning". Hard-deleted facts leave orphaned
+    association_edges (the FK cascade only fires under FK-on connections),
+    which spreading_activation then has to scan. Returns rows removed.
+    """
+    where = (
+        "profile_id = ? AND ("
+        "source_fact_id NOT IN (SELECT fact_id FROM atomic_facts WHERE profile_id = ?) "
+        "OR target_fact_id NOT IN (SELECT fact_id FROM atomic_facts WHERE profile_id = ?))"
+    )
+    c.execute(f"SELECT COUNT(*) AS cnt FROM association_edges WHERE {where}",
+              (profile_id, profile_id, profile_id))
+    n = c.fetchone()["cnt"]
+    if dry_run or not n:
+        return n
+    c.execute(f"DELETE FROM association_edges WHERE {where}",
+              (profile_id, profile_id, profile_id))
+    return c.rowcount
+
+
 def _remove_orphan_edges(
     c: sqlite3.Cursor,
     profile_id: str,
@@ -321,60 +353,64 @@ def _cap_node_degree(
       2. Edges with rn > max_degree are deleted in a single DELETE statement.
       Requires SQLite 3.25+ (window functions). System is on 3.53.1.
     """
+    # gi-03: cap BOTH out-degree (PARTITION BY source_id) AND in-degree
+    # (PARTITION BY target_id). Previously only out-degree was capped, so hub
+    # nodes accumulated unbounded in-degree (observed up to 1457), inflating
+    # entity-channel fan-in cost. An edge is removed if it exceeds max_degree
+    # in EITHER direction (low-weight to both its endpoints). Computed in one
+    # window-function pass, no Python loops.
     if dry_run:
         c.execute(
             """
             SELECT COUNT(*) as cnt FROM (
                 SELECT edge_id,
-                       ROW_NUMBER() OVER (
-                           PARTITION BY source_id ORDER BY weight DESC
-                       ) as rn
+                       ROW_NUMBER() OVER (PARTITION BY source_id ORDER BY weight DESC) as out_rn,
+                       ROW_NUMBER() OVER (PARTITION BY target_id ORDER BY weight DESC) as in_rn
                 FROM graph_edges
                 WHERE profile_id = ?
-            ) WHERE rn > ?
+            ) WHERE out_rn > ? OR in_rn > ?
             """,
-            (profile_id, max_degree),
+            (profile_id, max_degree, max_degree),
         )
         excess = c.fetchone()["cnt"]
         logger.info(
-            "(dry-run) _cap_node_degree: ~%d edges would be removed (max_degree=%d)",
+            "(dry-run) _cap_node_degree: ~%d edges would be removed (max_degree=%d, in+out)",
             excess, max_degree,
         )
         return excess
 
-    # Step 1: build temp keep-list in one pass (ROW_NUMBER ranks by weight DESC)
-    c.execute("CREATE TEMP TABLE IF NOT EXISTS _slm_keep_edges (edge_id TEXT PRIMARY KEY)")
-    c.execute("DELETE FROM _slm_keep_edges")  # idempotent if called twice
+    # Step 1: collect edges exceeding the cap in either direction (one pass).
+    c.execute("DROP TABLE IF EXISTS _slm_cap_del")
+    c.execute("CREATE TEMP TABLE _slm_cap_del (edge_id TEXT PRIMARY KEY)")
     c.execute(
         """
-        INSERT INTO _slm_keep_edges (edge_id)
+        INSERT OR IGNORE INTO _slm_cap_del (edge_id)
         SELECT edge_id FROM (
             SELECT edge_id,
-                   ROW_NUMBER() OVER (
-                       PARTITION BY source_id ORDER BY weight DESC
-                   ) as rn
+                   ROW_NUMBER() OVER (PARTITION BY source_id ORDER BY weight DESC) as out_rn,
+                   ROW_NUMBER() OVER (PARTITION BY target_id ORDER BY weight DESC) as in_rn
             FROM graph_edges
             WHERE profile_id = ?
-        ) WHERE rn <= ?
+        ) WHERE out_rn > ? OR in_rn > ?
         """,
-        (profile_id, max_degree),
+        (profile_id, max_degree, max_degree),
     )
 
-    # Step 2: delete everything not in keep-list (single DELETE)
+    # Step 2: delete the over-cap edges (single DELETE).
     c.execute(
         """
         DELETE FROM graph_edges
         WHERE profile_id = ?
-          AND edge_id NOT IN (SELECT edge_id FROM _slm_keep_edges)
+          AND edge_id IN (SELECT edge_id FROM _slm_cap_del)
         """,
         (profile_id,),
     )
     deleted = c.rowcount
 
-    c.execute("DROP TABLE IF EXISTS _slm_keep_edges")
+    c.execute("DROP TABLE IF EXISTS _slm_cap_del")
 
     logger.info(
-        "_cap_node_degree: deleted %d low-weight edges (max_degree=%d)",
+        "_cap_node_degree: deleted %d low-weight edges (max_degree=%d, in+out capped)",
         deleted, max_degree,
     )
     return deleted

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/maintenance.py

@@ -107,8 +107,17 @@ def run_maintenance(
         "fisher_coupled": 0,
         "sheaf_checked": 0,
         "entity_summaries_consolidated": 0,  # V3.4.40
+        "orphan_metadata_gc": 0,             # v3.6.4 (P1-3)
     }
 
+    # P1-3 (embeddings-vector-02): sweep orphaned embedding_metadata left by
+    # any FK-off delete path, so the semantic channel never maps to dead facts.
+    # Runs before the early-return so it sweeps even for empty profiles.
+    try:
+        counts["orphan_metadata_gc"] = db.gc_orphaned_embedding_metadata()
+    except Exception as exc:  # pragma: no cover - defensive
+        logger.debug("orphan metadata GC skipped: %s", exc)
+
     facts = db.get_all_facts(profile_id)
     if not facts:
         return counts

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/core/store_pipeline.py

@@ -102,6 +102,37 @@ def enrich_fact(
     )
 
 
+# ---------------------------------------------------------------------------
+# Vector dual-write helper (P1-2 / embeddings-vector-01)
+# ---------------------------------------------------------------------------
+
+def _upsert_fact_vectors(fact, profile_id, ann_index, vector_store, embedder=None):
+    """Dual-write a fact's embedding to the ANN index + sqlite-vec store.
+
+    Embeds on-demand when the fact has no embedding (e.g. consolidated
+    summary facts created without one), so UPDATE/SUPERSEDE and consolidated
+    facts remain visible to the semantic channel instead of having a row in
+    ``atomic_facts`` but none in the vector store.
+    """
+    if not getattr(fact, "embedding", None) and embedder is not None and fact.content:
+        try:
+            fact.embedding = embedder.embed(fact.content)
+        except Exception as _emb_exc:  # pragma: no cover - defensive
+            logger.debug("on-demand embed failed for %s: %s", fact.fact_id, _emb_exc)
+            return
+    if not getattr(fact, "embedding", None):
+        return
+    if ann_index:
+        ann_index.add(fact.fact_id, fact.embedding)
+    # V3.2: VectorStore upsert (sqlite-vec) -- dual-write (Rule 12)
+    if vector_store and getattr(vector_store, "available", False):
+        vector_store.upsert(
+            fact_id=fact.fact_id,
+            profile_id=profile_id,
+            embedding=fact.embedding,
+        )
+
+
 # ---------------------------------------------------------------------------
 # run_store  (was MemoryEngine.store)
 # ---------------------------------------------------------------------------
@@ -175,10 +206,20 @@ def run_store(
     )
     db.store_memory(record)
 
-    facts = fact_extractor.extract_facts(
-        turns=[content], session_id=session_id,
-        session_date=parsed_date, speaker_a=speaker,
-    )
+    try:
+        facts = fact_extractor.extract_facts(
+            turns=[content], session_id=session_id,
+            session_date=parsed_date, speaker_a=speaker,
+        )
+    except Exception as _extract_exc:
+        # P0-1 (remember-write-04): an extractor EXCEPTION (transient LLM/embed
+        # backend error) must NOT orphan the already-committed memory. The None
+        # guard below only handled a None *return*, not a raise. Treat a raise
+        # as "no facts" so the verbatim/raw fallback persists the content.
+        logger.warning(
+            "extract_facts() raised — falling back to raw fact: %s", _extract_exc,
+        )
+        facts = None
 
     # v3.4.38: Defensive None guard. extract_facts() returns None on transient
     # failures (embedding worker timeout, LLM call fail). Without this guard,
@@ -257,58 +298,77 @@ def run_store(
         )
 
         if consolidator:
-            action = consolidator.consolidate(fact, profile_id)
-            if action.action_type.value == "noop":
-                continue
-
-            # Opinion confidence tracking: reinforce or decay
-            if fact.fact_type == FactType.OPINION and action.action_type.value == "update":
-                try:
-                    existing = db.get_fact(action.new_fact_id)
-                    if existing and existing.fact_type == FactType.OPINION:
-                        new_conf = min(1.0, existing.confidence + 0.1)
-                        db.update_fact(action.new_fact_id, {"confidence": new_conf})
-                except Exception:
-                    pass
-            elif fact.fact_type == FactType.OPINION and action.action_type.value == "supersede":
-                try:
-                    old_id = getattr(action, "old_fact_id", None)
-                    if old_id:
-                        old_fact = db.get_fact(old_id)
-                        if old_fact:
-                            new_conf = max(0.0, old_fact.confidence - 0.2)
-                            db.update_fact(old_id, {"confidence": new_conf})
-                except Exception:
-                    pass
-
-            if action.action_type.value in ("update", "supersede"):
-                updated_fact = db.get_fact(action.new_fact_id)
-                if updated_fact:
-                    if graph_builder:
-                        graph_builder.build_edges(updated_fact, profile_id)
-                    if observation_builder:
-                        for eid in updated_fact.canonical_entities:
-                            observation_builder.update_profile(
-                                eid, updated_fact, profile_id,
-                            )
-                stored_ids.append(action.new_fact_id)
-                continue
-            # ADD case: consolidator already stored the fact (F8 fix)
-            # Fall through to post-processing below
+            try:
+                action = consolidator.consolidate(fact, profile_id)
+            except Exception as _consolidate_exc:
+                # P0-1 (remember-write-03): a consolidate failure (e.g. LLM
+                # timeout) must NOT orphan the already-committed memory. Fall
+                # back to storing the raw enriched fact so the content stays
+                # retrievable across all channels.
+                logger.warning(
+                    "consolidate() failed for fact %s — storing raw fact as "
+                    "fallback: %s", fact.fact_id, _consolidate_exc,
+                )
+                action = None
+
+            if action is not None:
+                if action.action_type.value == "noop":
+                    continue
+
+                # Opinion confidence tracking: reinforce or decay
+                if fact.fact_type == FactType.OPINION and action.action_type.value == "update":
+                    try:
+                        existing = db.get_fact(action.new_fact_id)
+                        if existing and existing.fact_type == FactType.OPINION:
+                            new_conf = min(1.0, existing.confidence + 0.1)
+                            db.update_fact(action.new_fact_id, {"confidence": new_conf})
+                    except Exception:
+                        pass
+                elif fact.fact_type == FactType.OPINION and action.action_type.value == "supersede":
+                    try:
+                        old_id = getattr(action, "old_fact_id", None)
+                        if old_id:
+                            old_fact = db.get_fact(old_id)
+                            if old_fact:
+                                new_conf = max(0.0, old_fact.confidence - 0.2)
+                                db.update_fact(old_id, {"confidence": new_conf})
+                    except Exception:
+                        pass
+
+                if action.action_type.value in ("update", "supersede"):
+                    updated_fact = db.get_fact(action.new_fact_id)
+                    if updated_fact:
+                        # P1-2 (embeddings-vector-01): the merged/superseding
+                        # fact must reach the vector store (embed on-demand if
+                        # it has none) — otherwise it is invisible to the
+                        # semantic channel despite living in atomic_facts.
+                        _upsert_fact_vectors(
+                            updated_fact, profile_id, ann_index, vector_store, embedder,
+                        )
+                        if graph_builder:
+                            graph_builder.build_edges(updated_fact, profile_id)
+                        if observation_builder:
+                            for eid in updated_fact.canonical_entities:
+                                observation_builder.update_profile(
+                                    eid, updated_fact, profile_id,
+                                )
+                    stored_ids.append(action.new_fact_id)
+                    continue
+                # ADD case: consolidator already stored the fact (F8 fix)
+                # Fall through to post-processing below
+            else:
+                # Consolidate failed → store the raw fact ourselves so the
+                # memory is never left without a retrievable fact, then fall
+                # through to post-processing (embeddings, graph, context).
+                db.store_fact(fact)
         else:
             db.store_fact(fact)
 
         stored_ids.append(fact.fact_id)
 
-        if fact.embedding and ann_index:
-            ann_index.add(fact.fact_id, fact.embedding)
-        # V3.2: VectorStore upsert (sqlite-vec) -- dual-write (Rule 12)
-        if fact.embedding and vector_store and vector_store.available:
-            vector_store.upsert(
-                fact_id=fact.fact_id,
-                profile_id=profile_id,
-                embedding=fact.embedding,
-            )
+        # Dual-write embedding to ANN index + vector store (embed on-demand if
+        # a consolidated ADD fact arrived without one). See _upsert_fact_vectors.
+        _upsert_fact_vectors(fact, profile_id, ann_index, vector_store, embedder)
         # Phase 2: Generate contextual description (after consolidator, before graph_builder)
         if context_generator:
             try:
@@ -489,6 +549,15 @@ def run_store_fact_direct(
     and graph edges are all populated — even for auxiliary data.
     Creates a parent memory record to satisfy FK constraint.
     """
+    # remember-write-02: gate low-quality content (empty, bare category tags,
+    # placeholder/template leakage) at the WRITE boundary, matching run_store's
+    # gate. Previously this direct path had no filter, so junk entered the KB
+    # and polluted evidence/stats/embeddings (the read-side filter only hid it).
+    from superlocalmemory.core.injection import is_low_quality
+    if is_low_quality(fact.content):
+        logger.debug("run_store_fact_direct: skipping low-quality content")
+        return fact.fact_id
+
     # Create parent memory record (FK: atomic_facts.memory_id → memories.memory_id)
     if not fact.memory_id:
         record = MemoryRecord(

superlocalmemory-3.6.4/src/superlocalmemory/mcp/_stdin_guard.py

@@ -0,0 +1,60 @@
+# 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
+
+"""Pure decision logic for the MCP stdin-EOF self-termination monitor.
+
+Isolated here (no imports, no side effects) so the kqueue ``EV_EOF``
+handling contract is unit-testable without importing the FastMCP server
+module, which starts daemon threads and auto-starts the SLM daemon at
+import time.
+
+Background (v3.6.4 fix)
+-----------------------
+The stdin-EOF monitor (``superlocalmemory.mcp.server._stdin_eof_monitor``)
+exists to reap orphaned ``slm mcp`` processes when an IDE/agent abandons the
+stdio pipe without quitting. It registers ``EVFILT_READ | EV_EOF`` on stdin
+and terminates the process when the write-end closes.
+
+On macOS, ``EVFILT_READ`` reports ``EV_EOF`` *together with* still-readable
+bytes (``ev.data > 0``) when the write-end is closed while a final request
+is still buffered in the pipe. The original monitor exited on the EOF flag
+alone — dropping that buffered request and tearing down a session that
+still had a pending in-flight call. Under strict MCP hosts whose transport
+half-closes stdin around reconnect/teardown, this surfaced as the server
+self-terminating mid-request, which the host then logged as a keepalive
+failure and respawned (observed against the Hermes agent).
+
+The guard defers termination until the buffer is genuinely drained
+(``ev.data <= 0``), letting the FastMCP reader consume the last request
+first. Genuine disconnects (EOF with an empty buffer) still terminate
+immediately — behaviour identical to before for the common case.
+"""
+
+from __future__ import annotations
+
+__all__ = ["eof_action"]
+
+
+def eof_action(flags: int, data: int, eof_flag: int) -> str:
+    """Decide how the stdin-EOF monitor should react to one kqueue event.
+
+    Args:
+        flags: ``kevent.flags`` bitmask returned by ``kqueue.control``.
+        data: ``kevent.data`` — for ``EVFILT_READ`` this is the number of
+            bytes still readable on the descriptor.
+        eof_flag: the platform ``select.KQ_EV_EOF`` constant (injected so
+            this function stays import-free and trivially testable).
+
+    Returns:
+        - ``"exit"``   — genuine end-of-stream: write-end closed and the
+          buffer is drained (``data <= 0``). Safe to self-terminate.
+        - ``"drain"``  — write-end closed but unread bytes remain
+          (``data > 0``). Must NOT terminate yet; let the reader consume
+          the buffered request first, otherwise it is silently dropped.
+        - ``"ignore"`` — no EOF on this event (ordinary readability or a
+          spurious wake); nothing to do.
+    """
+    if not (flags & eof_flag):
+        return "ignore"
+    return "drain" if data > 0 else "exit"

{superlocalmemory-3.6.3 → superlocalmemory-3.6.4}/src/superlocalmemory/mcp/server.py

@@ -288,11 +288,26 @@ _watchdog_thread.start()
 # closes WITHOUT consuming any bytes, so it cannot race with FastMCP's asyncio
 # stdin reader. On Linux (no kqueue), the watchdog alone provides coverage.
 def _stdin_eof_monitor() -> None:
-    """Exit when the IDE closes our stdin pipe (kqueue — macOS only)."""
-    import select as _sel, os as _os_eof
+    """Exit when the IDE closes our stdin pipe (kqueue — macOS only).
+
+    V3.6.4: kqueue ``EVFILT_READ`` reports ``EV_EOF`` *together with*
+    still-readable bytes (``ev.data > 0``) when the write-end closes while a
+    final request is buffered. Exiting on the EOF flag alone (pre-3.6.4)
+    dropped that in-flight request and self-terminated a session that still
+    had work to deliver — strict MCP hosts (e.g. the Hermes agent) then
+    logged a keepalive failure and respawned the process. We now defer
+    termination until the buffer is genuinely drained (see ``_stdin_guard``).
+    """
+    import select as _sel, os as _os_eof, time as _time
+    from superlocalmemory.mcp._stdin_guard import eof_action
     _mlog = logging.getLogger(__name__ + ".stdin_monitor")
     if not hasattr(_sel, "kqueue"):
         return  # Linux / non-macOS: watchdog covers process death
+    # Bounded grace for the FastMCP reader to drain a buffered final request
+    # before we tear down. ~2 s ceiling (40 × 50 ms): a genuine EOF means the
+    # session is ending regardless, so we never wait indefinitely.
+    _DRAIN_POLL_S = 0.05
+    _DRAIN_MAX_POLLS = 40
     try:
         fd = sys.stdin.fileno()
         kq = _sel.kqueue()
@@ -301,9 +316,23 @@ def _stdin_eof_monitor() -> None:
         while True:
             evs = kq.control(None, 4, 30.0)  # 30 s poll — low cost
             for ev in evs:
-                if ev.flags & _sel.KQ_EV_EOF:
-                    _mlog.info("stdin write-end closed (kqueue EOF), self-terminating")
-                    _os_eof._exit(0)
+                action = eof_action(ev.flags, ev.data, _sel.KQ_EV_EOF)
+                if action == "ignore":
+                    continue
+                if action == "drain":
+                    # Write-end closed but unread bytes remain. Let the
+                    # FastMCP reader consume the final request(s); poll until
+                    # drained or the grace ceiling elapses.
+                    for _ in range(_DRAIN_MAX_POLLS):
+                        _time.sleep(_DRAIN_POLL_S)
+                        recheck = kq.control(None, 4, 0)  # non-blocking
+                        if not recheck:
+                            break
+                        ev = recheck[0]
+                        if eof_action(ev.flags, ev.data, _sel.KQ_EV_EOF) != "drain":
+                            break
+                _mlog.info("stdin write-end closed (kqueue EOF, drained), self-terminating")
+                _os_eof._exit(0)
     except Exception as exc:
         _mlog.debug("stdin EOF monitor error: %s — watchdog will cover", exc)