superlocalmemory 3.4.58__tar.gz → 3.5.1__tar.gz

{superlocalmemory-3.4.58/src/superlocalmemory.egg-info → superlocalmemory-3.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.58
+Version: 3.5.1
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later
@@ -69,6 +69,8 @@ Provides-Extra: ui
 Requires-Dist: fastapi[all]>=0.135.1; extra == "ui"
 Requires-Dist: uvicorn>=0.42.0; extra == "ui"
 Requires-Dist: python-multipart<1.0.0,>=0.0.6; extra == "ui"
+Provides-Extra: injection
+Requires-Dist: tiktoken>=0.8.0; extra == "injection"
 Provides-Extra: learning
 Requires-Dist: lightgbm>=4.0.0; extra == "learning"
 Provides-Extra: performance
@@ -79,7 +81,7 @@ Requires-Dist: google-auth-oauthlib>=1.2.0; extra == "ingestion"
 Requires-Dist: google-api-python-client>=2.100.0; extra == "ingestion"
 Requires-Dist: icalendar>=6.0.0; extra == "ingestion"
 Provides-Extra: full
-Requires-Dist: superlocalmemory[ingestion,learning,performance,search,ui]; extra == "full"
+Requires-Dist: superlocalmemory[ingestion,injection,learning,performance,search,ui]; extra == "full"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.1; extra == "dev"

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.58"
+version = "3.5.1"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -89,6 +89,9 @@ ui = [
     "uvicorn>=0.42.0",
     "python-multipart>=0.0.6,<1.0.0",
 ]
+injection = [
+    "tiktoken>=0.8.0",
+]
 learning = [
     "lightgbm>=4.0.0",
 ]
@@ -102,7 +105,7 @@ ingestion = [
     "icalendar>=6.0.0",
 ]
 full = [
-    "superlocalmemory[search,ui,learning,performance,ingestion]",
+    "superlocalmemory[search,ui,learning,performance,ingestion,injection]",
 ]
 dev = [
     "pytest>=8.0",

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/__init__.py

@@ -28,7 +28,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.4.58"
+__version__ = "3.4.64"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/cli/commands.py

@@ -2067,14 +2067,18 @@ def cmd_session_context(args: Namespace) -> None:
     This ensures the SessionStart hook completes within its 15s timeout even
     when Ollama requires a 60s+ cold start.  The fast path returns:
       - Core Memory blocks (always-on context)
-      - Recent high-importance memories (last 7 days)
+      - Recent high-importance memories (last N days)
       - Session summary from last session
     Falls back to the full engine path only if --full is passed explicitly.
+
+    v3.4.65: uses shared injection formatter (render_context) for identical
+    output across MCP and CLI surfaces. --json flag returns structured JSON.
     """
     import sqlite3
     from pathlib import Path
     from superlocalmemory.core.config import SLMConfig
 
+    use_json = getattr(args, "json", False)
     use_full = getattr(args, "full", False)
 
     if use_full:
@@ -2093,13 +2097,21 @@ def cmd_session_context(args: Namespace) -> None:
                 query=getattr(args, "query", "") or "recent decisions and important context",
             )
             if context:
-                print(context)
+                if use_json:
+                    from superlocalmemory.cli.json_output import json_print
+                    json_print("session-context", data={"context": context}, next_actions=[
+                        {"command": "slm recall --json <query>", "description": "Search memories"},
+                    ])
+                else:
+                    print(context)
         except Exception as exc:
             logger.debug("session-context (full) failed: %s", exc)
         return
 
     # ── FAST PATH: direct SQLite, no engine, <500ms ──────────────
     try:
+        from superlocalmemory.core.injection import InjectableMemory, render_context
+
         config = SLMConfig.load()
         db_path = config.base_dir / "memory.db"
         if not db_path.exists():
@@ -2108,78 +2120,113 @@ def cmd_session_context(args: Namespace) -> None:
         pid = config.active_profile
         conn = sqlite3.connect(str(db_path))
         conn.row_factory = sqlite3.Row
-        sections = []
 
-        # 1. Core Memory blocks (compiled high-value context)
+        # Collect facts for injection — same queries as pre-v3.4.65 but
+        # mapped into InjectableMemory for the shared formatter.
+        inj_mems: list[InjectableMemory] = []
+
+        # Core Memory blocks (compiled high-value context)
         try:
-            rows = conn.execute(
+            cm_rows = conn.execute(
                 "SELECT block_type, content FROM core_memory_blocks "
                 "WHERE profile_id = ? ORDER BY block_type",
                 (pid,),
             ).fetchall()
-            if rows:
-                blocks = [f"[{r['block_type']}] {r['content']}" for r in rows]
-                sections.append("## Core Memory\n" + "\n".join(blocks))
+            for r in cm_rows:
+                content = f"[{r['block_type']}] {r['content']}"
+                inj_mems.append(InjectableMemory(
+                    content=content, score=1.0, fact_id="",
+                    importance=1.0, access_count=10,
+                    pinned=True,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 2. Recent important memories — age gate from --max-age-days (default 30)
+        # Recent important memories — age gate from --max-age-days (default 30)
         max_age = getattr(args, "max_age_days", 30)
         age_clause = (
             f"AND created_at >= datetime('now', '-{int(max_age)} days') "
             if max_age > 0 else ""
         )
         try:
-            rows = conn.execute(
-                "SELECT content, fact_type, created_at FROM atomic_facts "
+            fact_rows = conn.execute(
+                "SELECT fact_id, content, importance, access_count, fact_type FROM atomic_facts "
                 "WHERE profile_id = ? "
                 f"{age_clause}"
                 "AND lifecycle = 'active' "
                 "ORDER BY importance DESC, created_at DESC LIMIT 10",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = []
-                for r in rows:
-                    content = r["content"][:200]
-                    items.append(f"- [{r['fact_type'] or 'fact'}] {content}")
-                sections.append("## Recent Context (7 days)\n" + "\n".join(items))
+            for r in fact_rows:
+                inj_mems.append(InjectableMemory(
+                    content=r["content"],
+                    score=r["importance"] or 0.5,
+                    fact_id=r["fact_id"],
+                    importance=r["importance"] or 0.0,
+                    access_count=r["access_count"] or 0,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 3. Session markers (last session summary)
+        # Session markers (last session summary)
         try:
-            rows = conn.execute(
-                "SELECT content, created_at FROM atomic_facts "
+            sess_rows = conn.execute(
+                "SELECT fact_id, content, importance, access_count FROM atomic_facts "
                 "WHERE profile_id = ? AND content LIKE 'Session%' "
                 "ORDER BY created_at DESC LIMIT 3",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = [f"- {r['content'][:150]}" for r in rows]
-                sections.append("## Recent Sessions\n" + "\n".join(items))
+            for r in sess_rows:
+                inj_mems.append(InjectableMemory(
+                    content=r["content"],
+                    score=r["importance"] or 0.3,
+                    fact_id=r["fact_id"],
+                    importance=r["importance"] or 0.0,
+                    access_count=r["access_count"] or 0,
+                ))
         except sqlite3.OperationalError:
             pass
 
-        # 4. V3.3 Soft prompts (auto-learned patterns)
+        conn.close()
+
+        if not inj_mems:
+            return
+
+        # V3.3 Soft prompts (auto-learned patterns) — append as high-importance
         try:
-            rows = conn.execute(
+            conn2 = sqlite3.connect(str(db_path))
+            conn2.row_factory = sqlite3.Row
+            sp_rows = conn2.execute(
                 "SELECT category, content FROM soft_prompt_templates "
                 "WHERE profile_id = ? AND active = 1 "
                 "ORDER BY confidence DESC LIMIT 5",
                 (pid,),
             ).fetchall()
-            if rows:
-                items = [f"- [{r['category']}] {r['content'][:150]}" for r in rows]
-                sections.append("## Learned Patterns\n" + "\n".join(items))
-        except sqlite3.OperationalError:
+            conn2.close()
+            for r in sp_rows:
+                inj_mems.append(InjectableMemory(
+                    content=f"[{r['category']}] {r['content']}",
+                    score=0.7, fact_id="",
+                    importance=0.7, access_count=5,
+                ))
+        except Exception:
             pass
 
-        conn.close()
+        cfg_inj = getattr(config, "injection", None)
+        context = render_context(inj_mems, mode=config.mode.value.upper(), cfg=cfg_inj, wrap=True)
+        if context:
+            if use_json:
+                from superlocalmemory.cli.json_output import json_print
+                json_print("session-context", data={
+                    "context": context,
+                    "memory_count": len(inj_mems),
+                    "mode": config.mode.value.upper(),
+                }, next_actions=[
+                    {"command": "slm recall --json <query>", "description": "Search memories"},
+                ])
+            else:
+                print(context)
 
-        if sections:
-            header = f"# SLM Session Context — {config.active_profile}"
-            print(header + "\n\n" + "\n\n".join(sections))
     except Exception as exc:
         logger.debug("session-context (fast) failed: %s", exc)
 

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/cli/daemon.py

@@ -171,6 +171,17 @@ def _start_daemon_subprocess() -> bool:
     else:
         kwargs["start_new_session"] = True
 
+    # v3.4.60: Force OMP_NUM_THREADS=1 in daemon env BEFORE Python imports
+    # numpy/torch/lightgbm. Setting it in __init__.py is too late on M5 Pro —
+    # by the time superlocalmemory.__init__ runs, libomp has already been
+    # initialized by an earlier import, causing the SIGSEGV at
+    # __kmp_suspend_initialize_thread when lightgbm forks its worker pool.
+    # Forcing serial OpenMP eliminates the parallel barrier race entirely.
+    daemon_env = os.environ.copy()
+    daemon_env["OMP_NUM_THREADS"] = "1"
+    daemon_env["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+    kwargs["env"] = daemon_env
+
     with open(log_file, "a") as lf:
         proc = subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
 
@@ -523,8 +534,10 @@ class DaemonHandler(BaseHTTPRequestHandler):
                     session_id = f"http:{int(_t.time() * 1000)}"
 
                 engine = _get_engine()
+                raw_fast = params.get("fast", ["false"])[0]
+                fast = raw_fast.lower() in ("true", "1")
                 response = engine.recall(
-                    query, limit=limit, session_id=session_id,
+                    query, limit=limit, session_id=session_id, fast=fast,
                 )
                 # Return the same field shape as recall_worker._handle_recall,
                 # so MCP processes that proxy through the daemon get recall_trace-

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/cli/main.py

@@ -136,7 +136,7 @@ def main() -> None:
 
     mode_p = sub.add_parser("mode", help="Get or set operating mode (a/b/c)")
     mode_p.add_argument(
-        "value", nargs="?", choices=["a", "b", "c"], help="Mode to set",
+        "value", nargs="?", choices=["a", "b", "c", "A", "B", "C"], help="Mode to set",
     )
     mode_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/core/backend_orchestrator.py

@@ -62,7 +62,7 @@ class BackendOrchestrator:
     def __init__(self, config: SLMConfig, db: DatabaseManager) -> None:
         self._config = config
         self._db = db
-        self._data_dir = Path(config.data_dir)
+        self._data_dir = Path(getattr(config, "data_dir", None) or config.base_dir)
         self._cozo: Any = None
         self._lancedb: Any = None
         self._tiers: Any = None
@@ -236,22 +236,28 @@ class BackendOrchestrator:
     # ------------------------------------------------------------------
 
     def _detect_cozo(self) -> bool:
-        if self._config.get("graph_backend") == "sqlite":
-            return False
-        try:
-            import pycozo  # noqa: F401
-            return True
-        except ImportError:
+        gb = getattr(self._config, "graph_backend", "auto") or "auto"
+        if gb == "sqlite":
             return False
+        if gb in ("auto", "cozo"):
+            try:
+                import pycozo  # noqa: F401
+                return True
+            except ImportError:
+                return False
+        return False
 
     def _detect_lancedb(self) -> bool:
-        if self._config.get("vector_backend") == "sqlite-vec":
-            return False
-        try:
-            import lancedb  # noqa: F401
-            return True
-        except ImportError:
+        vb = getattr(self._config, "vector_backend", "auto") or "auto"
+        if vb == "sqlite-vec":
             return False
+        if vb in ("auto", "lancedb"):
+            try:
+                import lancedb  # noqa: F401
+                return True
+            except ImportError:
+                return False
+        return False
 
     # ------------------------------------------------------------------
     # Internal: Init

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/core/config.py

@@ -233,6 +233,50 @@ class MathConfig:
     # Rate-Distortion (production only, disabled for benchmarks)
 
 
+# ---------------------------------------------------------------------------
+# Context Injection (v3.4.65)
+# ---------------------------------------------------------------------------
+
+@dataclass(frozen=True)
+class InjectionConfig:
+    """Context-injection budgets & framing (v3.4.65).
+
+    Single source of truth for what reaches the agent at session_init,
+    prestage_context, and the recall hooks. Replaces scattered char caps.
+
+    Budgets are in *estimated tokens* (chars/4 heuristic; see
+    core/injection.estimate_tokens). Mode-aware: A=fast/cheap, C=rich.
+    """
+    enabled: bool = True
+
+    # Mode-aware TOTAL budget (core block + recall), in estimated tokens.
+    total_budget_tokens_a: int = 2000
+    total_budget_tokens_b: int = 4000
+    total_budget_tokens_c: int = 8000
+
+    # Per-memory ceiling (estimated tokens). Whole-memory inclusion until
+    # the total budget is hit; this only clamps a single oversized memory.
+    per_memory_max_tokens: int = 600
+
+    # Core Memory Block (Letta pattern).
+    core_block_enabled: bool = True
+    core_block_max_facts: int = 5
+    core_block_max_tokens: int = 1000
+    core_block_importance_min: float = 0.8
+    core_block_min_access_count: int = 2
+
+    # Lost-in-the-middle: place strongest at top & bottom edges.
+    edge_ordering: bool = True
+
+    # Trust framing. False (shipped) = cautious "reference only" wrapper.
+    # True (Varun personal) = clean "memory context" framing.
+    # redact_secrets ALWAYS runs regardless.
+    trust_first_party: bool = False
+
+    # prestage_context response byte cap (was hardcoded 16 KB).
+    prestage_max_response_bytes: int = 64 * 1024
+
+
 # ---------------------------------------------------------------------------
 # Master Config
 # ---------------------------------------------------------------------------
@@ -613,6 +657,10 @@ class SLMConfig:
     parameterization: ParameterizationConfig = field(
         default_factory=ParameterizationConfig,
     )
+    injection: InjectionConfig = field(default_factory=InjectionConfig)
+    # v3.5.0: scaling backends — "sqlite" / "cozo" / "auto" / "lancedb" / "sqlite-vec" / "auto".
+    graph_backend: str = "auto"       # "auto" = cozo if pycozo installed, else sqlite
+    vector_backend: str = "auto"      # "auto" = lancedb if installed, else sqlite-vec
     evolution: EvolutionConfig = field(default_factory=EvolutionConfig)
 
     # v3.4.3: Daemon configuration
@@ -701,6 +749,24 @@ class SLMConfig:
                 if k in EvolutionConfig.__dataclass_fields__
             })
 
+        # V3.4.65: Injection config (additive — defaults if missing from JSON)
+        inj = data.get("injection", {}) or {}
+        config.injection = InjectionConfig(
+            enabled=bool(inj.get("enabled", True)),
+            total_budget_tokens_a=int(inj.get("total_budget_tokens_a", 2000)),
+            total_budget_tokens_b=int(inj.get("total_budget_tokens_b", 4000)),
+            total_budget_tokens_c=int(inj.get("total_budget_tokens_c", 8000)),
+            per_memory_max_tokens=int(inj.get("per_memory_max_tokens", 600)),
+            core_block_enabled=bool(inj.get("core_block_enabled", True)),
+            core_block_max_facts=int(inj.get("core_block_max_facts", 5)),
+            core_block_max_tokens=int(inj.get("core_block_max_tokens", 1000)),
+            core_block_importance_min=float(inj.get("core_block_importance_min", 0.8)),
+            core_block_min_access_count=int(inj.get("core_block_min_access_count", 2)),
+            edge_ordering=bool(inj.get("edge_ordering", True)),
+            trust_first_party=bool(inj.get("trust_first_party", False)),
+            prestage_max_response_bytes=int(inj.get("prestage_max_response_bytes", 64 * 1024)),
+        )
+
         return config
 
     def save(
@@ -775,6 +841,23 @@ class SLMConfig:
             "max_evolutions_per_cycle": self.evolution.max_evolutions_per_cycle,
         }
 
+        # V3.4.65: Persist injection config
+        data["injection"] = {
+            "enabled": self.injection.enabled,
+            "total_budget_tokens_a": self.injection.total_budget_tokens_a,
+            "total_budget_tokens_b": self.injection.total_budget_tokens_b,
+            "total_budget_tokens_c": self.injection.total_budget_tokens_c,
+            "per_memory_max_tokens": self.injection.per_memory_max_tokens,
+            "core_block_enabled": self.injection.core_block_enabled,
+            "core_block_max_facts": self.injection.core_block_max_facts,
+            "core_block_max_tokens": self.injection.core_block_max_tokens,
+            "core_block_importance_min": self.injection.core_block_importance_min,
+            "core_block_min_access_count": self.injection.core_block_min_access_count,
+            "edge_ordering": self.injection.edge_ordering,
+            "trust_first_party": self.injection.trust_first_party,
+            "prestage_max_response_bytes": self.injection.prestage_max_response_bytes,
+        }
+
         # 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:

{superlocalmemory-3.4.58 → superlocalmemory-3.5.1}/src/superlocalmemory/core/graph_pruner.py

@@ -28,12 +28,18 @@ from pathlib import Path
 logger = logging.getLogger("superlocalmemory.graph_pruner")
 
 _CHAIN_BATCH_LIMIT = 10_000
+# v3.4.59: Nodes with more than this many total edges (in+out) are hub nodes.
+# SA and entity_graph channels cap fan-out at 30/node, so edges beyond this
+# threshold provide zero additional recall signal while bloating the graph.
+_MAX_DEGREE_PER_NODE: int = 100
+_HUB_PRUNE_BATCH: int = 500  # delete edges in batches to avoid giant IN clauses
 
 
 def prune_graph(
     db_path: str | Path,
     profile_id: str = "default",
     dry_run: bool = False,
+    cap_degree: bool = True,
 ) -> dict:
     """Run all graph pruning strategies for a specific profile.
 
@@ -41,7 +47,7 @@ def prune_graph(
     """
     conn = sqlite3.connect(str(db_path))
     conn.execute("PRAGMA journal_mode=WAL")
-    conn.execute("PRAGMA busy_timeout=10000")
+    conn.execute("PRAGMA busy_timeout=30000")
     conn.row_factory = sqlite3.Row
 
     stats = {
@@ -49,6 +55,7 @@ def prune_graph(
         "supersedes_collapsed": 0,
         "self_loops_removed": 0,
         "duplicates_removed": 0,
+        "hub_edges_removed": 0,
         "total_before": 0,
         "total_after": 0,
     }
@@ -72,6 +79,10 @@ def prune_graph(
         stats["supersedes_collapsed"] = _collapse_supersedes_chains(
             c, profile_id, dry_run,
         )
+        if cap_degree:
+            stats["hub_edges_removed"] = _cap_node_degree(
+                c, profile_id, _MAX_DEGREE_PER_NODE, dry_run,
+            )
 
         if dry_run:
             c.execute("ROLLBACK")
@@ -91,10 +102,11 @@ def prune_graph(
         prefix = "(dry-run) " if dry_run else ""
         logger.info(
             "%sGraph pruning: removed %d edges (%.1f%%) in %.1fs — "
-            "orphans=%d, supersedes=%d, self_loops=%d, duplicates=%d",
+            "orphans=%d, supersedes=%d, self_loops=%d, duplicates=%d, hub_cap=%d",
             prefix, total_removed, pct, elapsed,
             stats["orphans_removed"], stats["supersedes_collapsed"],
             stats["self_loops_removed"], stats["duplicates_removed"],
+            stats["hub_edges_removed"],
         )
 
     except Exception as exc:
@@ -288,3 +300,81 @@ def _collapse_supersedes_chains(
     )
 
     return len(delete_ids)
+
+
+def _cap_node_degree(
+    c: sqlite3.Cursor,
+    profile_id: str,
+    max_degree: int,
+    dry_run: bool,
+) -> int:
+    """Remove low-weight edges from hub nodes (nodes with degree > max_degree).
+
+    v3.4.59: At 17K facts, popular entities (SLM, Claude, AgentAssert) caused
+    1.4M+ entity edges — avg 121 per node, some nodes with 5000+. SA fan-out
+    is capped at 30/node during traversal, so edges beyond max_degree add zero
+    recall signal while making every graph query scan millions of rows.
+
+    Algorithm (single-pass window function — no Python loops):
+      1. ROW_NUMBER() OVER (PARTITION BY source_id ORDER BY weight DESC) ranks
+         every edge per node in one full table scan.
+      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.
+    """
+    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
+                FROM graph_edges
+                WHERE profile_id = ?
+            ) WHERE rn > ?
+            """,
+            (profile_id, max_degree),
+        )
+        excess = c.fetchone()["cnt"]
+        logger.info(
+            "(dry-run) _cap_node_degree: ~%d edges would be removed (max_degree=%d)",
+            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
+    c.execute(
+        """
+        INSERT INTO _slm_keep_edges (edge_id)
+        SELECT edge_id FROM (
+            SELECT edge_id,
+                   ROW_NUMBER() OVER (
+                       PARTITION BY source_id ORDER BY weight DESC
+                   ) as rn
+            FROM graph_edges
+            WHERE profile_id = ?
+        ) WHERE rn <= ?
+        """,
+        (profile_id, max_degree),
+    )
+
+    # Step 2: delete everything not in keep-list (single DELETE)
+    c.execute(
+        """
+        DELETE FROM graph_edges
+        WHERE profile_id = ?
+          AND edge_id NOT IN (SELECT edge_id FROM _slm_keep_edges)
+        """,
+        (profile_id,),
+    )
+    deleted = c.rowcount
+
+    c.execute("DROP TABLE IF EXISTS _slm_keep_edges")
+
+    logger.info(
+        "_cap_node_degree: deleted %d low-weight edges (max_degree=%d)",
+        deleted, max_degree,
+    )
+    return deleted