superlocalmemory 3.5.4__tar.gz → 3.5.6__tar.gz

{superlocalmemory-3.5.4/src/superlocalmemory.egg-info → superlocalmemory-3.5.6}/PKG-INFO

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

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/pyproject.toml

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

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory/core/engine.py

@@ -369,6 +369,91 @@ class MemoryEngine:
             vector_store=self._vector_store,
         )
 
+    def store_fast(self, content: str, metadata: dict[str, Any] | None = None) -> list[str]:
+        """v3.5.5 WRITE-THROUGH: synchronous verbatim insert for IMMEDIATE recall.
+
+        Full ``store()`` blocks 30-180s on LLM fact-extraction + Ollama embedding
+        + graph building. That created a recall window: a memory stored via the
+        async path sat in pending.db, unrecallable, until the background
+        materializer caught up. An agent storing a decision then immediately
+        recalling it (same session, or a parallel/next session) would miss it.
+
+        store_fast inserts a verbatim AtomicFact (+ memory row) synchronously.
+        The FTS5 ``atomic_facts_fts`` trigger auto-populates on INSERT, so the
+        memory is **keyword/BM25-recallable the instant this returns** (~ms, no
+        LLM, no embedding). Embedding + entities + graph are enriched async by
+        the materializer (which detects facts with NULL embedding).
+
+        Returns real fact_ids immediately. Quality gate rejects template junk.
+        """
+        self._require_full("store_fast")
+        self._ensure_init()
+        import re as _re
+        import uuid as _uuid
+        from datetime import datetime, timezone
+        from superlocalmemory.storage.models import (
+            AtomicFact, FactType, MemoryRecord,
+        )
+        if not content or not content.strip():
+            return []
+        try:
+            from superlocalmemory.core.injection import is_low_quality
+            if is_low_quality(content):
+                return []
+        except Exception:
+            pass
+        now = datetime.now(timezone.utc).isoformat()
+        record = MemoryRecord(
+            profile_id=self._profile_id, content=content,
+            session_date=now[:10], metadata=metadata or {},
+        )
+        self._db.store_memory(record)
+        # Lightweight regex entities (matches store_pipeline verbatim path) so
+        # the entity_graph channel has something to work with before enrichment.
+        ents = sorted(
+            {m.group(1) for m in _re.finditer(
+                r"\b([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})\b", content)}
+            | {m.group(1) for m in _re.finditer(r"\b([A-Z]{2,})\b", content)}
+        )
+        # v3.5.5: compute the embedding SYNCHRONOUSLY. A single warm embed is
+        # ~22ms (the 30-180s of full store() was LLM fact-extraction + graph,
+        # NOT embedding). With the embedding present, the semantic channel
+        # scores this fact correctly so it ranks properly IMMEDIATELY — not
+        # just keyword-findable but top-ranked. Graph/entity enrichment stays
+        # async. Embed failure → fact still inserted (keyword-recallable).
+        emb = None
+        fmean = fvar = None
+        try:
+            emb = self._embedder.embed(content) if self._embedder else None
+            if emb:
+                fmean, fvar = self._embedder.compute_fisher_params(emb)
+        except Exception:
+            emb = None
+        fact = AtomicFact(
+            fact_id=_uuid.uuid4().hex[:16], memory_id=record.memory_id,
+            profile_id=self._profile_id, content=content,
+            fact_type=FactType.EPISODIC, entities=ents,
+            observation_date=now[:10], confidence=0.7, importance=0.5,
+            embedding=emb, fisher_mean=fmean, fisher_variance=fvar,
+            created_at=now,
+        )
+        self._db.store_fact(fact)  # FTS5 trigger → immediately BM25-recallable
+        # Upsert to vector store so the semantic channel finds it now.
+        try:
+            vs = getattr(self, "_vector_store", None)
+            if emb and vs and getattr(vs, "available", False):
+                vs.upsert(fact.fact_id, self._profile_id, emb)
+        except Exception:
+            pass
+        # Persist BM25 tokens too (covers the in-memory rank_bm25 fallback path).
+        try:
+            bm25 = getattr(self._retrieval_engine, "_bm25", None)
+            if bm25:
+                bm25.add(fact.fact_id, content, self._profile_id)
+        except Exception:
+            pass
+        return [fact.fact_id]
+
     # -- Recall operations --------------------------------------------------
 
     def recall(

superlocalmemory-3.5.6/src/superlocalmemory/learning/lightgbm_subprocess.py

@@ -0,0 +1,236 @@
+# 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
+
+"""Isolated LightGBM work (retrain + consolidation) — OpenMP-crash guard.
+
+**Why this exists** — the unified daemon serves the HTTP API in-process and,
+by then, has already loaded PyTorch's OpenMP runtime (``torch/lib/libomp.dylib``)
+with *warm* worker threads (the cross-encoder reranker + embedding warm-up at
+startup). Any code path that imports ``lightgbm`` in that same process loads a
+*second* OpenMP runtime — the Homebrew ``libomp.dylib`` that
+``lib_lightgbm.dylib`` links against — which corrupts the shared ``__kmp``
+global state and SIGSEGVs a pre-existing torch OMP worker thread. That
+hard-crashes the whole daemon (observed on macOS / Apple Silicon;
+``DiagnosticReports/Python-*.ips`` shows ``libomp.dylib __kmp_launch_worker``).
+
+Two in-daemon entry points reach LightGBM training:
+  * ``POST /api/learning/retrain``  → legacy ``_retrain_ranker_impl``;
+  * ``POST /api/v3/learning/consolidate`` → ``ConsolidationWorker.run`` whose
+    step 5 trains via the online ``_run_shadow_cycle`` (active model) or the
+    legacy cold-start path.
+
+Both are funnelled through this module so LightGBM only ever trains in a
+**fresh subprocess** that never runs a torch tensor op — torch's OMP pool stays
+dormant there and lightgbm's runtime is the only active one. The mechanism
+mirrors the existing ``embedding_worker`` / ``reranker_worker`` isolation.
+
+Spawned via :func:`run_retrain_isolated` / :func:`run_consolidation_isolated`,
+which use a ``python -c`` bootstrap that imports lightgbm BEFORE the
+``superlocalmemory`` package. That ordering is load-bearing: importing the
+package transitively pulls in torch, and torch-OMP-first-then-lightgbm is
+exactly the sequence that segfaults. A plain ``python -m
+superlocalmemory.learning.lightgbm_subprocess`` would run the package
+``__init__`` (torch) first and crash — do not invoke it that way.
+
+The child emits a single JSON line on stdout — ``{"error": str|null, ...}`` —
+plus a task payload (``trained`` for retrain, ``stats`` for consolidate).
+Exit 0 = ran to completion; non-zero = handled failure. Either way the parent
+(the daemon) keeps running.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import subprocess
+import sys
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+# Wall-clock ceilings. A retrain is 50 boosting rounds on ≤2000 rows (seconds);
+# a full consolidation cycle also decays/dedups/mines/graph-analyses, so it
+# gets more headroom.
+RETRAIN_TIMEOUT_SEC = 300
+CONSOLIDATE_TIMEOUT_SEC = 600
+
+
+# ---------------------------------------------------------------------------
+# Child-side task implementations (run in the isolated subprocess).
+# ---------------------------------------------------------------------------
+
+def _retrain(learning_db: str, profile_id: str, *, include_synthetic: bool) -> bool:
+    """Legacy ranker retrain in this (lightgbm-first) process. Returns trained."""
+    import lightgbm  # noqa: F401  (import-order side effect is intentional)
+
+    from superlocalmemory.learning.ranker_retrain_legacy import (
+        _retrain_ranker_impl,
+    )
+
+    return bool(
+        _retrain_ranker_impl(
+            learning_db, profile_id, include_synthetic=include_synthetic,
+        )
+    )
+
+
+def _consolidate(
+    memory_db: str, learning_db: str, profile_id: str, *, dry_run: bool,
+) -> dict:
+    """Full consolidation cycle (incl. step-5 LightGBM training). Returns stats."""
+    import lightgbm  # noqa: F401  (import-order side effect is intentional)
+
+    from superlocalmemory.learning.consolidation_worker import (
+        ConsolidationWorker,
+    )
+
+    worker = ConsolidationWorker(memory_db, learning_db)
+    return worker.run(profile_id, dry_run=dry_run)
+
+
+def _emit(obj: dict) -> None:
+    """Write the verdict as a single JSON line (default=str for safety)."""
+    sys.stdout.write(json.dumps(obj, default=str) + "\n")
+    sys.stdout.flush()
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="slm-lightgbm-subprocess")
+    parser.add_argument("--task", choices=["retrain", "consolidate"], default="retrain")
+    parser.add_argument("--learning-db", required=True)
+    parser.add_argument("--memory-db")
+    parser.add_argument("--profile", default="default")
+    parser.add_argument("--include-synthetic", action="store_true")
+    parser.add_argument("--dry-run", action="store_true")
+    args = parser.parse_args(argv)
+
+    result: dict = {"error": None}
+    try:
+        if args.task == "retrain":
+            result["trained"] = _retrain(
+                args.learning_db, args.profile,
+                include_synthetic=args.include_synthetic,
+            )
+        else:
+            if not args.memory_db:
+                raise ValueError("--memory-db is required for the consolidate task")
+            result["stats"] = _consolidate(
+                args.memory_db, args.learning_db, args.profile,
+                dry_run=args.dry_run,
+            )
+    except Exception as exc:  # noqa: BLE001
+        result["error"] = f"{type(exc).__name__}: {exc}"
+        _emit(result)
+        return 1
+
+    _emit(result)
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# Caller-side helpers — spawn the child in an isolated process.
+# ---------------------------------------------------------------------------
+
+def _run_isolated(task_args: list[str], *, timeout_sec: int) -> dict:
+    """Spawn the child with lightgbm imported first; return its JSON verdict.
+
+    Never raises for the expected failure modes (non-zero exit, timeout,
+    native crash with no JSON) — encodes them in an ``error`` key so the
+    calling daemon stays up no matter what.
+    """
+    # The leading ``import lightgbm`` is load-bearing: it must run BEFORE the
+    # superlocalmemory package (which transitively imports torch). ``-c`` is
+    # the only way to guarantee that ordering — ``-m superlocalmemory.…`` runs
+    # the package __init__ (torch) first and would reintroduce the crash.
+    bootstrap = (
+        "import lightgbm; "
+        "from superlocalmemory.learning.lightgbm_subprocess import main; "
+        "raise SystemExit(main())"
+    )
+    cmd = [sys.executable, "-c", bootstrap, *task_args]
+
+    try:
+        proc = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout_sec,
+            check=False,
+        )
+    except subprocess.TimeoutExpired:
+        return {"error": f"timed out after {timeout_sec}s"}
+    except Exception as exc:  # noqa: BLE001
+        return {"error": f"spawn failed: {exc}"}
+
+    # The verdict is the last JSON line on stdout. Parse defensively — a native
+    # crash in the child would leave no JSON, which we surface plainly.
+    for line in reversed((proc.stdout or "").splitlines()):
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            return json.loads(line)
+        except ValueError:
+            continue
+
+    tail = (proc.stderr or "").strip()[-500:]
+    return {
+        "error": (
+            f"subprocess produced no verdict (exit={proc.returncode}). "
+            f"stderr tail: {tail}"
+        ),
+    }
+
+
+def run_retrain_isolated(
+    learning_db: str | Path,
+    profile_id: str,
+    *,
+    include_synthetic: bool = False,
+    timeout_sec: int = RETRAIN_TIMEOUT_SEC,
+) -> dict:
+    """Train the ranker in a subprocess. Returns ``{"trained": bool, "error": ...}``."""
+    args = [
+        "--task", "retrain",
+        "--learning-db", str(learning_db),
+        "--profile", profile_id,
+    ]
+    if include_synthetic:
+        args.append("--include-synthetic")
+    verdict = _run_isolated(args, timeout_sec=timeout_sec)
+    verdict.setdefault("trained", False)
+    verdict.setdefault("error", None)
+    return verdict
+
+
+def run_consolidation_isolated(
+    memory_db: str | Path,
+    learning_db: str | Path,
+    profile_id: str,
+    *,
+    dry_run: bool = False,
+    timeout_sec: int = CONSOLIDATE_TIMEOUT_SEC,
+) -> dict:
+    """Run the full consolidation cycle in a subprocess (its step-5 training
+    would otherwise crash the torch-warm daemon).
+
+    Returns ``{"stats": dict|None, "error": str|None}``.
+    """
+    args = [
+        "--task", "consolidate",
+        "--memory-db", str(memory_db),
+        "--learning-db", str(learning_db),
+        "--profile", profile_id,
+    ]
+    if dry_run:
+        args.append("--dry-run")
+    verdict = _run_isolated(args, timeout_sec=timeout_sec)
+    verdict.setdefault("stats", None)
+    verdict.setdefault("error", None)
+    return verdict
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory/mcp/tools_core.py

@@ -110,27 +110,45 @@ def register_core_tools(server, get_engine: Callable) -> None:
         Extracts atomic facts, resolves entities, builds graph edges,
         and indexes for 4-channel retrieval.
         """
+        meta = {
+            "project": project,
+            "importance": importance,
+            "agent_id": agent_id,
+            "session_id": session_id,
+        }
+        # v3.5.5 WRITE-THROUGH: route through the daemon's /remember, which does
+        # a synchronous verbatim insert (memory is keyword/BM25-recallable the
+        # instant this returns) and enqueues async enrichment. This closes the
+        # recall window so a parallel/next agent finds memories saved seconds ago.
+        # Falls back to pending.db only if the daemon is unreachable.
         try:
-            # v3.4.32: Store-first pattern. Write to pending.db and return
-            # immediately. The daemon's pending-materializer thread drains
-            # the queue with recall priority, so concurrent MCP remembers
-            # no longer contend with /search on the shared embedder.
-            from superlocalmemory.cli.pending_store import store_pending
-
-            pending_id = store_pending(content, tags=tags, metadata={
-                "project": project,
-                "importance": importance,
-                "agent_id": agent_id,
-                "session_id": session_id,
-            })
+            from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
+            if is_daemon_running():
+                resp = daemon_request("POST", "/remember", {
+                    "content": content, "tags": tags, "metadata": meta,
+                })
+                if resp and (resp.get("fact_ids") is not None or resp.get("ok")):
+                    fids = resp.get("fact_ids") or []
+                    return {
+                        "success": True,
+                        "fact_ids": fids or [f"pending:{resp.get('pending_id','')}"],
+                        "count": len(fids) if fids else 1,
+                        "pending": not fids,
+                        "message": "Stored (recallable now; enriching async).",
+                    }
+        except Exception as dexc:
+            logger.debug("MCP remember via daemon failed, pending fallback: %s", dexc)
 
+        try:
+            from superlocalmemory.cli.pending_store import store_pending
+            pending_id = store_pending(content, tags=tags, metadata=meta)
             return {
                 "success": True,
                 "fact_ids": [f"pending:{pending_id}"],
                 "count": 1,
                 "pending": True,
                 "pending_id": pending_id,
-                "message": "Stored — facts will appear in the dashboard shortly.",
+                "message": "Stored — facts will appear shortly (daemon offline).",
             }
         except Exception as exc:
             logger.exception("remember failed")

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory/server/routes/learning.py

@@ -15,6 +15,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 
 from fastapi import APIRouter
+from fastapi.concurrency import run_in_threadpool
 
 from .helpers import get_active_profile, MEMORY_DIR
 
@@ -597,16 +598,31 @@ async def learning_retrain(data: dict | None = None):
         data and data.get("include_synthetic")
     ) if isinstance(data, dict) else False
     try:
-        from superlocalmemory.learning.consolidation_worker import (
-            _retrain_ranker_impl,
+        # Train OUT OF PROCESS. The daemon already has torch's OpenMP runtime
+        # loaded with warm worker threads; importing lightgbm in-process loads
+        # a second libomp and SIGSEGVs the whole daemon (see
+        # retrain_subprocess module docstring). Isolation is the fix.
+        from superlocalmemory.learning.lightgbm_subprocess import (
+            run_retrain_isolated,
         )
         profile_id = get_active_profile() or "default"
-        trained = _retrain_ranker_impl(
+        result = await run_in_threadpool(
+            run_retrain_isolated,
             LEARNING_DB,
             profile_id,
             include_synthetic=include_synthetic,
         )
-        if trained:
+        if result.get("error"):
+            logger.error("learning_retrain failed: %s", result["error"])
+            return {"success": False, "error": result["error"]}
+        if result.get("trained"):
+            # Drop the cached model so the next recall reloads the freshly
+            # trained one the subprocess just persisted to learning.db.
+            try:
+                from superlocalmemory.learning.model_cache import invalidate
+                invalidate(profile_id)
+            except Exception as exc:  # pragma: no cover — defensive
+                logger.debug("model cache invalidate failed: %s", exc)
             return {
                 "success": True,
                 "trained": True,

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory/server/routes/v3_api.py

@@ -806,15 +806,37 @@ async def run_consolidation(request: Request):
     try:
         body = await request.json()
         dry_run = body.get("dry_run", False)
-        from superlocalmemory.learning.consolidation_worker import ConsolidationWorker
+        # Run the full cycle OUT OF PROCESS. Step 5 trains the LightGBM ranker
+        # (online _run_shadow_cycle or legacy cold-start); importing lightgbm
+        # in the torch-warm daemon loads a second libomp and SIGSEGVs it (see
+        # lightgbm_subprocess module docstring). Isolation is the fix.
+        from superlocalmemory.learning.lightgbm_subprocess import (
+            run_consolidation_isolated,
+        )
         from superlocalmemory.core.config import SLMConfig
         from superlocalmemory.server.routes.helpers import DB_PATH
-        worker = ConsolidationWorker(
-            memory_db=str(DB_PATH),
-            learning_db=str(DB_PATH.parent / "learning.db"),
-        )
+        from fastapi.concurrency import run_in_threadpool
+
         config = SLMConfig.load()
-        stats = worker.run(config.active_profile, dry_run=dry_run)
+        learning_db = DB_PATH.parent / "learning.db"
+        result = await run_in_threadpool(
+            run_consolidation_isolated,
+            str(DB_PATH),
+            str(learning_db),
+            config.active_profile,
+            dry_run=dry_run,
+        )
+        if result.get("error"):
+            return {"success": False, "error": result["error"]}
+        # Step-5 training may have promoted a new model — drop the daemon's
+        # cached model so the next recall reloads it from learning.db.
+        if not dry_run:
+            try:
+                from superlocalmemory.learning.model_cache import invalidate
+                invalidate(config.active_profile)
+            except Exception:
+                pass
+        stats = result.get("stats") or {}
         return {"success": True, **stats}
     except Exception as exc:
         return {"success": False, "error": str(exc)}

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory/server/unified_daemon.py

@@ -1582,14 +1582,28 @@ def _register_daemon_routes(application: FastAPI) -> None:
             extra = getattr(req, "metadata", None)
             if isinstance(extra, dict):
                 meta.update(extra)
+            # v3.5.5 WRITE-THROUGH: synchronous verbatim insert → the memory is
+            # keyword/BM25-recallable the instant this returns (~ms). Closes the
+            # recall window so a parallel/next agent finds memories saved seconds
+            # ago. Embedding/graph enrichment is deferred to the materializer.
+            fact_ids: list[str] = []
+            try:
+                fact_ids = engine.store_fast(req.content, metadata=meta)
+            except Exception as fexc:
+                logger.warning("store_fast failed, falling back to pending-only: %s", fexc)
+            # Enqueue for async enrichment (embedding + entities + graph). The
+            # materializer detects the already-inserted verbatim fact and enriches
+            # it in place rather than duplicating.
             pending_id = store_pending(
                 req.content, tags=req.tags or "", metadata=meta,
             )
             return {
                 "ok": True,
+                "fact_ids": fact_ids,
+                "count": len(fact_ids),
                 "pending_id": pending_id,
-                "status": "queued",
-                "note": "materialized async; pass ?wait=true for legacy sync",
+                "status": "stored" if fact_ids else "queued",
+                "note": "write-through: recallable now; enriching async",
             }
         except Exception as exc:
             raise HTTPException(500, detail=str(exc))
@@ -1816,14 +1830,36 @@ def _start_pending_materializer() -> None:
                     try:
                         import hashlib
                         content = item["content"]
-                        # Dedup: skip if identical content already stored.
                         content_hash = hashlib.md5(content.encode()).hexdigest()
+                        # v3.5.5: the write-through path already inserted a
+                        # verbatim fact (recallable via BM25). If it lacks an
+                        # embedding, ENRICH it in place (compute embedding +
+                        # upsert vector store) rather than skipping — otherwise
+                        # the fact would never be semantically searchable.
                         dup = engine._db.execute(
-                            "SELECT 1 FROM atomic_facts WHERE "
-                            "content = ? LIMIT 1",
+                            "SELECT fact_id, embedding FROM atomic_facts "
+                            "WHERE content = ? LIMIT 1",
                             (content,),
                         )
                         if dup:
+                            try:
+                                row = dict(dup[0])
+                                if not row.get("embedding") and engine._embedder:
+                                    emb = engine._embedder.embed(content)
+                                    if emb:
+                                        upd = {"embedding": emb}
+                                        try:
+                                            fm, fv = engine._embedder.compute_fisher_params(emb)
+                                            upd["fisher_mean"] = fm
+                                            upd["fisher_variance"] = fv
+                                        except Exception:
+                                            pass
+                                        engine._db.update_fact(row["fact_id"], upd)
+                                        vs = getattr(engine, "_vector_store", None)
+                                        if vs and getattr(vs, "available", False):
+                                            vs.upsert(row["fact_id"], engine._profile_id, emb)
+                            except Exception as eexc:
+                                logger.debug("enrichment of write-through fact failed: %s", eexc)
                             mark_done(item["id"])
                             continue
                         import json as _json
@@ -1914,10 +1950,19 @@ def start_server(port: int = _DEFAULT_PORT) -> None:
     log_dir = Path.home() / ".superlocalmemory" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
 
+    # Bind address. `SLM_DAEMON_HOST` is the canonical name; `SLM_HOST` is
+    # accepted as a shorter alias (issue #23). Set either to 0.0.0.0 to serve
+    # a shared instance over a trusted private network (e.g. WireGuard mesh).
+    bind_host = (
+        os.environ.get("SLM_DAEMON_HOST")
+        or os.environ.get("SLM_HOST")
+        or "127.0.0.1"
+    )
+
     config = uvicorn.Config(
         app="superlocalmemory.server.unified_daemon:create_app",
         factory=True,
-        host=os.environ.get("SLM_DAEMON_HOST", "127.0.0.1"),
+        host=bind_host,
         port=port,
         log_level="warning",
         timeout_graceful_shutdown=10,

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6/src/superlocalmemory.egg-info}/PKG-INFO

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

{superlocalmemory-3.5.4 → superlocalmemory-3.5.6}/src/superlocalmemory.egg-info/SOURCES.txt

@@ -221,6 +221,7 @@ src/superlocalmemory/learning/forgetting_scheduler.py
 src/superlocalmemory/learning/hnsw_dedup.py
 src/superlocalmemory/learning/labeler.py
 src/superlocalmemory/learning/legacy_migration.py
+src/superlocalmemory/learning/lightgbm_subprocess.py
 src/superlocalmemory/learning/memory_merge.py
 src/superlocalmemory/learning/model_cache.py
 src/superlocalmemory/learning/model_rollback.py