superlocalmemory 3.8.2__tar.gz → 3.8.4__tar.gz

{superlocalmemory-3.8.2/src/superlocalmemory.egg-info → superlocalmemory-3.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.8.2
+Version: 3.8.4
 Summary: Local-first agent memory with auditable hybrid retrieval
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License-Expression: AGPL-3.0-or-later
@@ -106,10 +106,10 @@ Dynamic: license-file
   </picture>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.8.2</h1>
+<h1 align="center">SuperLocalMemory V3.8.4</h1>
 <p align="center"><strong>Enterprise-grade, local-first memory for AI agents and teams.</strong><br/>
 <em>A persistent, auditable long-term brain for your agents that runs on your own infrastructure — with multi-workspace isolation, role-based access, and GDPR + EU AI Act governance controls built in.</em></p>
-<p align="center"><code>v3.8.2</code> — one control plane: auditable retrieval · multi-scope memory (personal / shared / global) · Cache · Compress · trusted-peer Mesh · bounded loops — across CLI, MCP, dashboard, the <strong>Claude plugin</strong>, the <strong>Codex add-on</strong>, and documented IDE integrations.<br/>
+<p align="center"><code>v3.8.4</code> — one control plane: auditable retrieval · multi-scope memory (personal / shared / global) · Cache · Compress · trusted-peer Mesh · bounded loops — across CLI, MCP, dashboard, the <strong>Claude plugin</strong>, the <strong>Codex add-on</strong>, and documented IDE integrations.<br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/README.md

@@ -5,10 +5,10 @@
   </picture>
 </p>
 
-<h1 align="center">SuperLocalMemory V3.8.2</h1>
+<h1 align="center">SuperLocalMemory V3.8.4</h1>
 <p align="center"><strong>Enterprise-grade, local-first memory for AI agents and teams.</strong><br/>
 <em>A persistent, auditable long-term brain for your agents that runs on your own infrastructure — with multi-workspace isolation, role-based access, and GDPR + EU AI Act governance controls built in.</em></p>
-<p align="center"><code>v3.8.2</code> — one control plane: auditable retrieval · multi-scope memory (personal / shared / global) · Cache · Compress · trusted-peer Mesh · bounded loops — across CLI, MCP, dashboard, the <strong>Claude plugin</strong>, the <strong>Codex add-on</strong>, and documented IDE integrations.<br/>
+<p align="center"><code>v3.8.4</code> — one control plane: auditable retrieval · multi-scope memory (personal / shared / global) · Cache · Compress · trusted-peer Mesh · bounded loops — across CLI, MCP, dashboard, the <strong>Claude plugin</strong>, the <strong>Codex add-on</strong>, and documented IDE integrations.<br/>
 Proxy: <code>slm wrap claude</code> &nbsp;·&nbsp; MCP: add <code>slm_compress</code> to your config &nbsp;·&nbsp; Skill: zero-config</p>
 <p align="center"><strong>3 public research preprints</strong> (arXiv + Zenodo archives) · <a href="https://arxiv.org/abs/2603.02240">arXiv:2603.02240</a> · <a href="https://arxiv.org/abs/2603.14588">arXiv:2603.14588</a> · <a href="https://arxiv.org/abs/2604.04514">arXiv:2604.04514</a></p>
 

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/rules/AGENTS.md

@@ -128,4 +128,4 @@ When the SLM MCP server is unavailable, use these CLI equivalents:
 - **slm-optimize-advisor** — context compression and KV cache
 - **slm-governance-advisor** — scope/role compliance, retention policies, GDPR
 
-SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-cache/SKILL.md

@@ -145,4 +145,4 @@ These subcommands control daemon-level cache settings. They do not read or write
 
 ---
 
-SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-compress/SKILL.md

@@ -147,4 +147,4 @@ Content over 1 MB (1 000 000 bytes UTF-8) is processed but `reversible` is force
 
 ---
 
-SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-graph/SKILL.md

@@ -311,4 +311,4 @@ profile. See `slm-profile` for the full profile switching workflow.
 
 ---
 
-SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-recall/SKILL.md

@@ -236,4 +236,4 @@ before recalling, then switch back. See `slm-profile` for workspace switching.
 
 ---
 
-*SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later*
+*SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later*

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-remember/SKILL.md

@@ -238,4 +238,4 @@ different workspace, use `switch_profile` first. See `slm-profile`.
 
 ---
 
-*SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later*
+*SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later*

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-session/SKILL.md

@@ -227,4 +227,4 @@ explicitly and call `recall` with `include_global`/`include_shared` after
 
 ---
 
-*SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later*
+*SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later*

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/plugin-src/skills/slm-status/SKILL.md

@@ -163,4 +163,4 @@ multi-profile setup. To switch the active profile, see `slm-profile`.
 
 ---
 
-SuperLocalMemory v3.8.2 · Qualixar · AGPL-3.0-or-later
+SuperLocalMemory v3.8.4 · Qualixar · AGPL-3.0-or-later

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.8.2"
+version = "3.8.4"
 description = "Local-first agent memory with auditable hybrid retrieval"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/src/superlocalmemory/__init__.py

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

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/src/superlocalmemory/access/rbac.py

@@ -32,6 +32,7 @@ from __future__ import annotations
 import hashlib
 import hmac
 import logging
+import os
 import secrets
 import sqlite3
 import uuid
@@ -39,9 +40,14 @@ from datetime import datetime, timedelta, timezone
 from enum import Enum
 from pathlib import Path
 
+from superlocalmemory.storage.memory_write import memory_write
+
 logger = logging.getLogger("superlocalmemory.access.rbac")
 
-_BUSY_TIMEOUT_MS = 4000
+# Match the daemon's default (SLM_DB_BUSY_TIMEOUT_MS, default 10 000 ms).
+# Reads use this via _conn(); writes go through memory_write() which reads the
+# same env var internally, so in-process writers never see SQLITE_BUSY.
+_BUSY_TIMEOUT_MS: int = max(0, int(os.environ.get("SLM_DB_BUSY_TIMEOUT_MS", "10000")))
 _SESSION_TTL_HOURS = 12
 
 # scrypt cost parameters (OWASP-recommended interactive-login range).
@@ -155,16 +161,15 @@ class RbacEngine:
             raise RbacError("Username is required.")
         pw_hash = _hash_password(password)
         user_id = _uid()
-        conn = self._conn()
-        try:
+        # memory_write: process write lock + busy_timeout.
+        with memory_write(self._db_path) as conn:
             # The UNIQUE(username) constraint is the source of truth; the SELECT
             # is a fast path. Two concurrent creates can both pass the SELECT, so
             # the loser's INSERT hits the constraint — convert that to RbacError
             # (409) instead of leaking a raw IntegrityError as a 500.
-            exists = conn.execute(
+            if conn.execute(
                 "SELECT 1 FROM rbac_users WHERE username=?", (username,)
-            ).fetchone()
-            if exists:
+            ).fetchone():
                 raise RbacError(f"User '{username}' already exists.")
             try:
                 conn.execute(
@@ -174,19 +179,15 @@ class RbacEngine:
                     (user_id, username, display_name or username, pw_hash,
                      _now(), created_by),
                 )
-                conn.commit()
             except sqlite3.IntegrityError:
                 raise RbacError(f"User '{username}' already exists.")
-        finally:
-            conn.close()
         logger.info("RBAC: created user '%s' (%s)", username, user_id)
         return {"user_id": user_id, "username": username,
                 "display_name": display_name or username, "status": "active"}
 
     def set_password(self, user_id: str, password: str) -> None:
         pw_hash = _hash_password(password)
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             cur = conn.execute(
                 "UPDATE rbac_users SET password_hash=? WHERE user_id=?",
                 (pw_hash, user_id),
@@ -195,15 +196,11 @@ class RbacEngine:
                 raise RbacError("User not found.")
             # A password change invalidates every existing session.
             conn.execute("DELETE FROM rbac_sessions WHERE user_id=?", (user_id,))
-            conn.commit()
-        finally:
-            conn.close()
 
     def set_status(self, user_id: str, status: str) -> None:
         if status not in ("active", "disabled"):
             raise RbacError("status must be 'active' or 'disabled'.")
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             cur = conn.execute(
                 "UPDATE rbac_users SET status=? WHERE user_id=?", (status, user_id)
             )
@@ -211,21 +208,14 @@ class RbacEngine:
                 raise RbacError("User not found.")
             if status == "disabled":
                 conn.execute("DELETE FROM rbac_sessions WHERE user_id=?", (user_id,))
-            conn.commit()
-        finally:
-            conn.close()
 
     def delete_user(self, user_id: str) -> None:
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             conn.execute("DELETE FROM rbac_sessions WHERE user_id=?", (user_id,))
             conn.execute("DELETE FROM rbac_memberships WHERE user_id=?", (user_id,))
             cur = conn.execute("DELETE FROM rbac_users WHERE user_id=?", (user_id,))
             if cur.rowcount == 0:
                 raise RbacError("User not found.")
-            conn.commit()
-        finally:
-            conn.close()
 
     def get_user(self, user_id: str) -> dict | None:
         conn = self._conn()
@@ -277,25 +267,35 @@ class RbacEngine:
         raw = secrets.token_urlsafe(32)
         now = datetime.now(timezone.utc)
         expires = (now + timedelta(hours=ttl_hours)).isoformat()
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             conn.execute(
                 "INSERT INTO rbac_sessions (token_hash, user_id, created_at, "
                 "expires_at, last_seen) VALUES (?, ?, ?, ?, ?)",
                 (_hash_token(raw), user_id, now.isoformat(), expires, now.isoformat()),
             )
-            conn.commit()
-        finally:
-            conn.close()
         return raw
 
     def resolve_session(self, raw_token: str) -> dict | None:
         """Return the active user for a session token, or None if invalid /
-        expired / disabled. Updates last_seen. Constant-time by hash lookup."""
+        expired / disabled. Updates last_seen. Constant-time by hash lookup.
+
+        Concurrency design
+        ------------------
+        Phase 1 (read): WAL allows concurrent readers without blocking the
+        writer — ``_conn()`` with ``busy_timeout`` only.  The write lock is
+        NOT taken here so a burst of concurrent requests doesn't serialise
+        through the single writer on every call.
+
+        Phase 2 (conditional write): only if the session is expired/stale.
+        ``memory_write()`` is opened AFTER the read connection is closed
+        (lock-ordering invariant: get_write_lock is outermost).
+        """
         if not raw_token:
             return None
         token_hash = _hash_token(raw_token)
         now = datetime.now(timezone.utc)
+
+        # -- Phase 1: read-only lookup ----------------------------------------
         conn = self._conn()
         try:
             row = conn.execute(
@@ -310,48 +310,52 @@ class RbacEngine:
                 expired = datetime.fromisoformat(row["expires_at"]) <= now
             except ValueError:
                 expired = True
-            if expired or row["status"] != "active":
-                conn.execute("DELETE FROM rbac_sessions WHERE token_hash=?", (token_hash,))
-                conn.commit()
-                return None
-            # Debounce last_seen: only write when it is stale (>60s), so a burst
-            # of authenticated requests does not serialize through the single
-            # SQLite writer on every call.
+            row_status = row["status"]
+            row_last_seen = row["last_seen"]
+            user_dict = {
+                "user_id": row["user_id"],
+                "username": row["username"],
+                "display_name": row["display_name"],
+            }
+        finally:
+            conn.close()
+
+        # -- Phase 2: write if needed (read conn closed above) ----------------
+        if expired or row_status != "active":
+            with memory_write(self._db_path) as wconn:
+                wconn.execute(
+                    "DELETE FROM rbac_sessions WHERE token_hash=?", (token_hash,)
+                )
+            return None
+
+        # Debounce last_seen: only write when stale (>60 s), so a burst of
+        # authenticated requests does not serialise through the writer every call.
+        stale = True
+        try:
+            stale = (now - datetime.fromisoformat(row_last_seen)).total_seconds() > 60
+        except (ValueError, TypeError, KeyError):
             stale = True
-            try:
-                stale = (now - datetime.fromisoformat(row["last_seen"])).total_seconds() > 60
-            except (ValueError, TypeError, KeyError):
-                stale = True
-            if stale:
-                conn.execute(
+        if stale:
+            with memory_write(self._db_path) as wconn:
+                wconn.execute(
                     "UPDATE rbac_sessions SET last_seen=? WHERE token_hash=?",
                     (now.isoformat(), token_hash),
                 )
-                conn.commit()
-            return {"user_id": row["user_id"], "username": row["username"],
-                    "display_name": row["display_name"]}
-        finally:
-            conn.close()
+        return user_dict
 
     def revoke_session(self, raw_token: str) -> None:
-        conn = self._conn()
-        try:
-            conn.execute("DELETE FROM rbac_sessions WHERE token_hash=?",
-                         (_hash_token(raw_token),))
-            conn.commit()
-        finally:
-            conn.close()
+        with memory_write(self._db_path) as conn:
+            conn.execute(
+                "DELETE FROM rbac_sessions WHERE token_hash=?",
+                (_hash_token(raw_token),),
+            )
 
     def purge_expired_sessions(self) -> int:
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             cur = conn.execute(
                 "DELETE FROM rbac_sessions WHERE expires_at <= ?", (_now(),)
             )
-            conn.commit()
-            return cur.rowcount or 0
-        finally:
-            conn.close()
+        return cur.rowcount or 0
 
     # -- memberships ------------------------------------------------------
 
@@ -361,8 +365,7 @@ class RbacEngine:
             role_enum = Role(role)
         except ValueError:
             raise RbacError(f"Invalid role '{role}'. Use admin/member/viewer.")
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             if not conn.execute(
                 "SELECT 1 FROM rbac_users WHERE user_id=?", (user_id,)
             ).fetchone():
@@ -374,21 +377,14 @@ class RbacEngine:
                 "added_at=excluded.added_at, added_by=excluded.added_by",
                 (profile_id, user_id, role_enum.value, _now(), added_by),
             )
-            conn.commit()
-        finally:
-            conn.close()
         return {"profile_id": profile_id, "user_id": user_id, "role": role_enum.value}
 
     def remove_membership(self, profile_id: str, user_id: str) -> None:
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             conn.execute(
                 "DELETE FROM rbac_memberships WHERE profile_id=? AND user_id=?",
                 (profile_id, user_id),
             )
-            conn.commit()
-        finally:
-            conn.close()
 
     def get_role(self, user_id: str, profile_id: str) -> Role | None:
         conn = self._conn()
@@ -442,16 +438,12 @@ class RbacEngine:
             conn.close()
 
     def set_policy(self, key: str, value: str) -> None:
-        conn = self._conn()
-        try:
+        with memory_write(self._db_path) as conn:
             conn.execute(
                 "INSERT INTO rbac_settings (key, value) VALUES (?, ?) "
                 "ON CONFLICT(key) DO UPDATE SET value=excluded.value",
                 (key, value),
             )
-            conn.commit()
-        finally:
-            conn.close()
 
     def require_login(self) -> bool:
         """Company mode: mutations require a valid user session (no owner

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/src/superlocalmemory/cli/commands.py

@@ -1135,6 +1135,9 @@ def cmd_connect(args: Namespace) -> None:
         if ide_arg in IDE_MATRIX:
             here = getattr(args, "here", False)
             profile = getattr(args, "profile", None)
+            transport = getattr(args, "transport", "stdio")
+            daemon_port = getattr(args, "daemon_port", 8765)
+            verify = getattr(args, "verify", False)
             project = None
             if here:
                 import pathlib
@@ -1148,8 +1151,24 @@ def cmd_connect(args: Namespace) -> None:
                 profile=profile,
                 agents_md_source=_agents_md_source_factory(),
                 dry_run=getattr(args, "dry_run", False),
+                transport=transport,
+                daemon_port=daemon_port,
             )
 
+            # --verify: probe daemon health after writing
+            if verify and transport in ("http", "http-mcp-remote") and not result.get("error"):
+                from superlocalmemory.hooks.portable_kit import _check_daemon_health
+                reachable = _check_daemon_health(daemon_port)
+                if reachable:
+                    print(f"[verify] Daemon reachable at http://127.0.0.1:{daemon_port}/api/v3/health")
+                else:
+                    print(
+                        f"[verify] Warning: daemon NOT reachable at "
+                        f"http://127.0.0.1:{daemon_port}/api/v3/health. "
+                        f"Run `slm serve start` to start it.",
+                        file=sys.stderr,
+                    )
+
             if not result.get("error") and not getattr(args, "dry_run", False):
                 from superlocalmemory.infra.local_diagnostics import record_operation
 

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/src/superlocalmemory/cli/ingest_cmd.py

@@ -281,15 +281,25 @@ def _write_tool_events(events: list[dict]) -> int:
 
     v3.4.10: Preserves input_summary, output_summary, and project_path
     from enriched sources (ECC observations, enriched hook).
+
+    Concurrency note
+    ----------------
+    ``slm ingest`` is a SEPARATE OS process — the daemon's threading.RLock
+    write-lock cannot help here.  PRAGMA busy_timeout is the only cross-process
+    lever: it makes SQLite WAIT for the single writer (daemon / hook) to finish
+    instead of immediately raising SQLITE_BUSY.  The ``timeout`` kwarg to
+    sqlite3.connect is the Python-level retry budget (same duration).
     """
     db_path = Path(MEMORY_DB)
     if not db_path.exists():
         return 0
 
-    conn = sqlite3.connect(str(db_path), timeout=10)
+    _busy_ms = 10_000
+    conn = sqlite3.connect(str(db_path), timeout=_busy_ms / 1000.0)
     count = 0
 
     try:
+        conn.execute(f"PRAGMA busy_timeout={_busy_ms}")
         for ev in events:
             try:
                 conn.execute(

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/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(

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/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()

{superlocalmemory-3.8.2 → superlocalmemory-3.8.4}/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
 # ---------------------------------------------------------------------------
@@ -1010,6 +1033,8 @@ class SLMConfig:
     scale_engine_state: str = "local_core"  # local_core | prepared | verified | promoted
     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.
@@ -1174,6 +1199,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(
@@ -1329,6 +1379,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: