superlocalmemory 4.0.10 → 4.1.2

package/src/superlocalmemory/cli/gdpr_cmd.py

@@ -427,9 +427,14 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
         sys.exit(1)
 
     complete = counts.get("erasure_complete", 0)
+    # Whether it can be SHOWN to have happened is a separate answer, and
+    # printing COMPLETE while the tamper-evident receipt failed to persist is
+    # how the command line came to disagree with the API about the same erasure.
+    provable = counts.get("erasure_provable", complete)
     result_data = {
         "profile": profile,
         "erasure_complete": bool(complete),
+        "erasure_provable": bool(provable),
         "counts": counts,
         "note": (
             "Erasure recorded in audit_chain.db. "
@@ -441,7 +446,15 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
     if use_json:
         _print_json(_json_envelope("gdpr-erase", data=result_data))
     else:
-        status_str = "COMPLETE" if complete else "INCOMPLETE (check counts)"
+        if not complete:
+            status_str = "INCOMPLETE (check counts)"
+        elif not provable:
+            status_str = (
+                "COMPLETE, BUT NOT PROVABLE — the data is gone and the "
+                "tamper-evident receipt did not persist"
+            )
+        else:
+            status_str = "COMPLETE"
         print(f"Art.17 erasure for profile '{profile}': {status_str}")
         for k, v in counts.items():
             print(f"  {k}: {v}")
@@ -449,7 +462,7 @@ def _cmd_gdpr_erase(args: Namespace) -> None:
         print("  Backups/ contain outstanding obligation — see C1 gap.")
         print("  Verify receipts: slm gdpr verify --profile", profile)
 
-    if not complete:
+    if not complete or not provable:
         sys.exit(1)
 
 

package/src/superlocalmemory/cli/main.py

@@ -24,7 +24,10 @@ _os.environ.setdefault('TORCH_DEVICE', 'cpu')
 import argparse
 import sys
 
-from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
+from superlocalmemory.core.config import (
+    CANONICAL_LIST_LIMIT,
+    CANONICAL_RECALL_LIMIT,
+)
 
 _HELP_EPILOG = """\
 operating modes:
@@ -344,6 +347,19 @@ def main() -> None:
     db_scale_p.add_argument("--stage-id", help="Stage identifier required by verify/promote")
     db_scale_p.add_argument("--backup-id", help="Backup identifier required by rollback")
 
+    db_regraph_p = db_sub.add_parser(
+        "regraph",
+        help="Re-derive the graph copy of your memories from the store",
+    )
+    db_regraph_p.add_argument(
+        "--check", action="store_true",
+        help="Report how far the graph copy has drifted; change nothing",
+    )
+    db_regraph_p.add_argument(
+        "--profile", default="",
+        help="Workspace to re-derive. Default: all of them",
+    )
+
     db_reembed_p = db_sub.add_parser(
         "reembed",
         help="Backfill NULL embeddings (facts never embedded)",
@@ -503,7 +519,8 @@ def main() -> None:
 
     list_p = sub.add_parser("list", help="List recent memories chronologically (shows IDs for delete/update)")
     list_p.add_argument(
-        "--limit", "-n", type=int, default=20, help="Number of entries (default 20)",
+        "--limit", "-n", type=int, default=CANONICAL_LIST_LIMIT,
+        help=f"Number of entries (default {CANONICAL_LIST_LIMIT})",
     )
     list_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
@@ -530,6 +547,11 @@ def main() -> None:
         "--quick", action="store_true",
         help="Run only the fast checks (deps + config); skip daemon/embedding probes",
     )
+    doctor_p.add_argument(
+        "--deep", action="store_true",
+        help="Read every database page (PRAGMA integrity_check) instead of the "
+             "structural check; slow on a large store",
+    )
     doctor_p.add_argument(
         "--fix", action="store_true",
         help="Auto-repair fixable components (re-download missing models, "

package/src/superlocalmemory/code_graph/database.py

@@ -37,6 +37,49 @@ _MAX_RETRIES = 5
 _RETRY_BASE_SECONDS = 0.1
 
 
+def _load_vector_extension(conn: sqlite3.Connection) -> bool:
+    """Make vector search available on this connection. Returns whether it loaded.
+
+    Without this the vector table cannot be created, so every semantic lookup
+    over the code graph returned nothing — not an error, just an empty result,
+    with one line in the maintenance log saying embeddings were disabled. The
+    extension was installed and working the whole time; no connection ever asked
+    for it.
+
+    Loaded per connection because that is the only scope SQLite offers: an
+    extension is bound to a connection, not to a database file, and this class
+    opens a fresh connection per statement.
+
+    The import stays inside the function. At module level it would make the
+    whole code graph unimportable wherever the wheel is unavailable, which is a
+    platform detail and not a reason to lose the rest of the feature.
+    """
+    try:
+        import sqlite_vec
+    except Exception as exc:  # ImportError, or a broken native build
+        logger.debug("vector search unavailable: %s", exc)
+        return False
+    try:
+        conn.enable_load_extension(True)
+    except AttributeError as exc:
+        # Python built against a SQLite without extension support.
+        logger.debug("this SQLite cannot load extensions: %s", exc)
+        return False
+    try:
+        sqlite_vec.load(conn)
+        return True
+    except Exception as exc:
+        logger.debug("vector extension failed to load: %s", exc)
+        return False
+    finally:
+        # Closed again either way. Leaving extension loading enabled on a
+        # connection widens what any later SQL on it is allowed to do.
+        try:
+            conn.enable_load_extension(False)
+        except Exception:  # pragma: no cover — defensive
+            pass
+
+
 class CodeGraphDatabase:
     """SQLite database manager for code_graph.db.
 
@@ -70,6 +113,7 @@ class CodeGraphDatabase:
         conn.execute("PRAGMA journal_mode=WAL")
         conn.execute("PRAGMA foreign_keys=ON")
         conn.execute("PRAGMA synchronous=NORMAL")
+        _load_vector_extension(conn)
         return conn
 
     def execute(